import $ from "jquery";
import { vsprintf, sprintf } from "sprintf-js";
import { WorkerScriptStartStopEventEmitter } from "./Netscript/WorkerScriptStartStopEventEmitter";
import { BitNodeMultipliers } from "./BitNode/BitNodeMultipliers";
import { CONSTANTS } from "./Constants";
import {
  calculateHackingChance,
  calculateHackingExpGain,
  calculatePercentMoneyHacked,
  calculateHackingTime,
  calculateGrowTime,
  calculateWeakenTime,
} from "./Hacking";
import { netscriptCanGrow, netscriptCanWeaken } from "./Hacking/netscriptCanHack";
import { Terminal } from "./Terminal";
import { Player } from "./Player";
import { Programs } from "./Programs/Programs";
import { Script } from "./Script/Script";
import { isScriptFilename } from "./Script/isScriptFilename";
import { PromptEvent } from "./ui/React/PromptManager";
import { GetServer, DeleteServer, AddToAllServers, createUniqueRandomIp } from "./Server/AllServers";
import {
  getServerOnNetwork,
  numCycleForGrowth,
  numCycleForGrowthCorrected,
  processSingleServerGrowth,
  safetlyCreateUniqueServer,
} from "./Server/ServerHelpers";
import { getPurchaseServerCost, getPurchaseServerLimit, getPurchaseServerMaxRam } from "./Server/ServerPurchases";
import { Server } from "./Server/Server";
import { influenceStockThroughServerGrow } from "./StockMarket/PlayerInfluencing";
import { isValidFilePath, removeLeadingSlash } from "./Terminal/DirectoryHelpers";
import { TextFile, getTextFile, createTextFile } from "./TextFile";
import { runScriptFromScript } from "./NetscriptWorker";
import { killWorkerScript } from "./Netscript/killWorkerScript";
import { workerScripts } from "./Netscript/WorkerScripts";
import { WorkerScript } from "./Netscript/WorkerScript";
import { helpers } from "./Netscript/NetscriptHelpers";
import { numeralWrapper } from "./ui/numeralFormat";
import { convertTimeMsToTimeElapsedString } from "./utils/StringHelperFunctions";
import { LogBoxEvents, LogBoxCloserEvents, LogBoxPositionEvents, LogBoxSizeEvents } from "./ui/React/LogBoxManager";
import { arrayToString } from "./utils/helpers/arrayToString";
import { isString } from "./utils/helpers/isString";
import { NetscriptGang } from "./NetscriptFunctions/Gang";
import { NetscriptSleeve } from "./NetscriptFunctions/Sleeve";
import { NetscriptExtra } from "./NetscriptFunctions/Extra";
import { NetscriptHacknet } from "./NetscriptFunctions/Hacknet";
import { NetscriptStanek } from "./NetscriptFunctions/Stanek";
import { NetscriptInfiltration } from "./NetscriptFunctions/Infiltration";
import { NetscriptUserInterface } from "./NetscriptFunctions/UserInterface";
import { NetscriptBladeburner } from "./NetscriptFunctions/Bladeburner";
import { NetscriptCodingContract } from "./NetscriptFunctions/CodingContract";
import { NetscriptCorporation } from "./NetscriptFunctions/Corporation";
import { NetscriptFormulas } from "./NetscriptFunctions/Formulas";
import { NetscriptStockMarket } from "./NetscriptFunctions/StockMarket";
import { NetscriptGrafting } from "./NetscriptFunctions/Grafting";
import { IPort } from "./NetscriptPort";
import {
  NS,
  Player as INetscriptPlayer,
  RecentScript as IRecentScript,
  BasicHGWOptions,
  ProcessInfo,
  HackingMultipliers,
  HacknetMultipliers,
  BitNodeMultipliers as IBNMults,
  Server as IServerDef,
  RunningScript as IRunningScriptDef,
} from "./ScriptEditor/NetscriptDefinitions";
import { NetscriptSingularity } from "./NetscriptFunctions/Singularity";

import { dialogBoxCreate } from "./ui/React/DialogBox";
import { SnackbarEvents, ToastVariant } from "./ui/React/Snackbar";
import { checkEnum } from "./utils/helpers/checkEnum";

import { Flags } from "./NetscriptFunctions/Flags";
import { calculateIntelligenceBonus } from "./PersonObjects/formulas/intelligence";
import { CalculateShareMult, StartSharing } from "./NetworkShare/Share";
import { recentScripts } from "./Netscript/RecentScripts";
import { InternalAPI, NetscriptContext, wrapAPI } from "./Netscript/APIWrapper";
import { INetscriptExtra } from "./NetscriptFunctions/Extra";
import { ScriptDeath } from "./Netscript/ScriptDeath";

export type NSFull = NS & INetscriptExtra;

export function NetscriptFunctions(workerScript: WorkerScript): NSFull {
  return wrapAPI(workerScript, ns, workerScript.args.slice());
}

const base: InternalAPI<NS> = {
  args: [],
  enums: {
    toast: ToastVariant,
  },

  singularity: NetscriptSingularity(),
  gang: NetscriptGang(),
  bladeburner: NetscriptBladeburner(),
  codingcontract: NetscriptCodingContract(),
  sleeve: NetscriptSleeve(),
  corporation: NetscriptCorporation(),
  stanek: NetscriptStanek(),
  infiltration: NetscriptInfiltration(),
  ui: NetscriptUserInterface(),
  formulas: NetscriptFormulas(),
  stock: NetscriptStockMarket(),
  grafting: NetscriptGrafting(),
  hacknet: NetscriptHacknet(),
  sprintf: () => sprintf,
  vsprintf: () => vsprintf,
  scan:
    (ctx: NetscriptContext) =>
    (_hostname: unknown = ctx.workerScript.hostname): string[] => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      const out = [];
      for (let i = 0; i < server.serversOnNetwork.length; i++) {
        const s = getServerOnNetwork(server, i);
        if (s === null) continue;
        const entry = s.hostname;
        if (entry === null) continue;
        out.push(entry);
      }
      helpers.log(ctx, () => `returned ${server.serversOnNetwork.length} connections for ${server.hostname}`);
      return out;
    },
  hack:
    (ctx: NetscriptContext) =>
    (_hostname: unknown, { threads: requestedThreads, stock }: BasicHGWOptions = {}): Promise<number> => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      return helpers.hack(ctx, hostname, false, { threads: requestedThreads, stock: stock });
    },
  hackAnalyzeThreads:
    (ctx: NetscriptContext) =>
    (_hostname: unknown, _hackAmount: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const hackAmount = helpers.number(ctx, "hackAmount", _hackAmount);

      // Check argument validity
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return -1;
      }
      if (isNaN(hackAmount)) {
        throw helpers.makeRuntimeErrorMsg(
          ctx,
          `Invalid hackAmount argument passed into hackAnalyzeThreads: ${hackAmount}. Must be numeric.`,
        );
      }

      if (hackAmount < 0 || hackAmount > server.moneyAvailable) {
        return -1;
      } else if (hackAmount === 0) {
        return 0;
      }

      const percentHacked = calculatePercentMoneyHacked(server, Player);

      if (percentHacked === 0 || server.moneyAvailable === 0) {
        return 0; // To prevent returning infinity below
      }

      return hackAmount / Math.floor(server.moneyAvailable * percentHacked);
    },
  hackAnalyze:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);

      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 0;
      }

      return calculatePercentMoneyHacked(server, Player);
    },
  hackAnalyzeSecurity:
    (ctx: NetscriptContext) =>
    (_threads: unknown, _hostname?: unknown): number => {
      let threads = helpers.number(ctx, "threads", _threads);
      if (_hostname) {
        const hostname = helpers.string(ctx, "hostname", _hostname);
        const server = helpers.getServer(ctx, hostname);
        if (!(server instanceof Server)) {
          helpers.log(ctx, () => "Cannot be executed on this server.");
          return 0;
        }

        const percentHacked = calculatePercentMoneyHacked(server, Player);

        if (percentHacked > 0) {
          // thread count is limited to the maximum number of threads needed
          threads = Math.min(threads, Math.ceil(1 / percentHacked));
        }
      }

      return CONSTANTS.ServerFortifyAmount * threads;
    },
  hackAnalyzeChance:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);

      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 0;
      }

      return calculateHackingChance(server, Player);
    },
  sleep:
    (ctx: NetscriptContext) =>
    async (_time: unknown = 0): Promise<true> => {
      const time = helpers.number(ctx, "time", _time);
      if (time === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
      }
      helpers.log(ctx, () => `Sleeping for ${time} milliseconds`);
      return helpers.netscriptDelay(ctx, time).then(function () {
        return Promise.resolve(true);
      });
    },
  asleep: (ctx: NetscriptContext) =>
    function (_time: unknown = 0): Promise<true> {
      const time = helpers.number(ctx, "time", _time);
      helpers.log(ctx, () => `Sleeping for ${time} milliseconds`);
      return new Promise((resolve) => setTimeout(() => resolve(true), time));
    },
  grow:
    (ctx: NetscriptContext) =>
    async (_hostname: unknown, { threads: requestedThreads, stock }: BasicHGWOptions = {}): Promise<number> => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const threads = helpers.resolveNetscriptRequestedThreads(
        ctx,
        requestedThreads ?? ctx.workerScript.scriptRef.threads,
      );

      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return Promise.resolve(0);
      }

      const host = GetServer(ctx.workerScript.hostname);
      if (host === null) {
        throw new Error("Workerscript host is null");
      }

      // No root access or skill level too low
      const canHack = netscriptCanGrow(server);
      if (!canHack.res) {
        throw helpers.makeRuntimeErrorMsg(ctx, canHack.msg || "");
      }

      const growTime = calculateGrowTime(server, Player);
      helpers.log(
        ctx,
        () =>
          `Executing on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(
            growTime * 1000,
            true,
          )} (t=${numeralWrapper.formatThreads(threads)}).`,
      );
      return helpers.netscriptDelay(ctx, growTime * 1000).then(function () {
        const moneyBefore = server.moneyAvailable <= 0 ? 1 : server.moneyAvailable;
        processSingleServerGrowth(server, threads, Player, host.cpuCores);
        const moneyAfter = server.moneyAvailable;
        ctx.workerScript.scriptRef.recordGrow(server.hostname, threads);
        const expGain = calculateHackingExpGain(server, Player) * threads;
        const logGrowPercent = moneyAfter / moneyBefore - 1;
        helpers.log(
          ctx,
          () =>
            `Available money on '${server.hostname}' grown by ${numeralWrapper.formatPercentage(
              logGrowPercent,
              6,
            )}. Gained ${numeralWrapper.formatExp(expGain)} hacking exp (t=${numeralWrapper.formatThreads(threads)}).`,
        );
        ctx.workerScript.scriptRef.onlineExpGained += expGain;
        Player.gainHackingExp(expGain);
        if (stock) {
          influenceStockThroughServerGrow(server, moneyAfter - moneyBefore);
        }
        return Promise.resolve(moneyAfter / moneyBefore);
      });
    },
  growthAnalyze:
    (ctx: NetscriptContext) =>
    (_hostname: unknown, _growth: unknown, _cores: unknown = 1): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const growth = helpers.number(ctx, "growth", _growth);
      const cores = helpers.number(ctx, "cores", _cores);

      // Check argument validity
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 0;
      }
      if (typeof growth !== "number" || isNaN(growth) || growth < 1 || !isFinite(growth)) {
        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: growth must be numeric and >= 1, is ${growth}.`);
      }

      return numCycleForGrowth(server, Number(growth), Player, cores);
    },
  growthAnalyzeSecurity:
    (ctx: NetscriptContext) =>
    (_threads: unknown, _hostname?: unknown, _cores?: unknown): number => {
      let threads = helpers.number(ctx, "threads", _threads);
      if (_hostname) {
        const cores = helpers.number(ctx, "cores", _cores) || 1;
        const hostname = helpers.string(ctx, "hostname", _hostname);
        const server = helpers.getServer(ctx, hostname);

        if (!(server instanceof Server)) {
          helpers.log(ctx, () => "Cannot be executed on this server.");
          return 0;
        }

        const maxThreadsNeeded = Math.ceil(
          numCycleForGrowthCorrected(server, server.moneyMax, server.moneyAvailable, Player, cores),
        );

        threads = Math.min(threads, maxThreadsNeeded);
      }

      return 2 * CONSTANTS.ServerFortifyAmount * threads;
    },
  weaken:
    (ctx: NetscriptContext) =>
    async (_hostname: unknown, { threads: requestedThreads }: BasicHGWOptions = {}): Promise<number> => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const threads = helpers.resolveNetscriptRequestedThreads(
        ctx,
        requestedThreads ?? ctx.workerScript.scriptRef.threads,
      );
      if (hostname === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
      }
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return Promise.resolve(0);
      }

      // No root access or skill level too low
      const canHack = netscriptCanWeaken(server);
      if (!canHack.res) {
        throw helpers.makeRuntimeErrorMsg(ctx, canHack.msg || "");
      }

      const weakenTime = calculateWeakenTime(server, Player);
      helpers.log(
        ctx,
        () =>
          `Executing on '${server.hostname}' in ${convertTimeMsToTimeElapsedString(
            weakenTime * 1000,
            true,
          )} (t=${numeralWrapper.formatThreads(threads)})`,
      );
      return helpers.netscriptDelay(ctx, weakenTime * 1000).then(function () {
        const host = GetServer(ctx.workerScript.hostname);
        if (host === null) {
          helpers.log(ctx, () => "Server is null, did it die?");
          return Promise.resolve(0);
        }
        const coreBonus = 1 + (host.cpuCores - 1) / 16;
        server.weaken(CONSTANTS.ServerWeakenAmount * threads * coreBonus);
        ctx.workerScript.scriptRef.recordWeaken(server.hostname, threads);
        const expGain = calculateHackingExpGain(server, Player) * threads;
        helpers.log(
          ctx,
          () =>
            `'${server.hostname}' security level weakened to ${
              server.hackDifficulty
            }. Gained ${numeralWrapper.formatExp(expGain)} hacking exp (t=${numeralWrapper.formatThreads(threads)})`,
        );
        ctx.workerScript.scriptRef.onlineExpGained += expGain;
        Player.gainHackingExp(expGain);
        return Promise.resolve(CONSTANTS.ServerWeakenAmount * threads * coreBonus);
      });
    },
  weakenAnalyze:
    (ctx: NetscriptContext) =>
    (_threads: unknown, _cores: unknown = 1): number => {
      const threads = helpers.number(ctx, "threads", _threads);
      const cores = helpers.number(ctx, "cores", _cores);
      const coreBonus = 1 + (cores - 1) / 16;
      return CONSTANTS.ServerWeakenAmount * threads * coreBonus * BitNodeMultipliers.ServerWeakenRate;
    },
  share: (ctx: NetscriptContext) => async (): Promise<void> => {
    helpers.log(ctx, () => "Sharing this computer.");
    const end = StartSharing(
      ctx.workerScript.scriptRef.threads * calculateIntelligenceBonus(Player.skills.intelligence, 2),
    );
    return helpers.netscriptDelay(ctx, 10000).finally(function () {
      helpers.log(ctx, () => "Finished sharing this computer.");
      end();
    });
  },
  getSharePower: () => (): number => {
    return CalculateShareMult();
  },
  print:
    (ctx: NetscriptContext) =>
    (...args: unknown[]): void => {
      if (args.length === 0) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Takes at least 1 argument.");
      }
      ctx.workerScript.print(helpers.argsToString(args));
    },
  printf:
    (ctx: NetscriptContext) =>
    (_format: unknown, ...args: unknown[]): void => {
      const format = helpers.string(ctx, "format", _format);
      if (typeof format !== "string") {
        throw helpers.makeRuntimeErrorMsg(ctx, "First argument must be string for the format.");
      }
      ctx.workerScript.print(vsprintf(format, args));
    },
  tprint:
    (ctx: NetscriptContext) =>
    (...args: unknown[]): void => {
      if (args.length === 0) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Takes at least 1 argument.");
      }
      const str = helpers.argsToString(args);
      if (str.startsWith("ERROR") || str.startsWith("FAIL")) {
        Terminal.error(`${ctx.workerScript.scriptRef.filename}: ${str}`);
        return;
      }
      if (str.startsWith("SUCCESS")) {
        Terminal.success(`${ctx.workerScript.scriptRef.filename}: ${str}`);
        return;
      }
      if (str.startsWith("WARN")) {
        Terminal.warn(`${ctx.workerScript.scriptRef.filename}: ${str}`);
        return;
      }
      if (str.startsWith("INFO")) {
        Terminal.info(`${ctx.workerScript.scriptRef.filename}: ${str}`);
        return;
      }
      Terminal.print(`${ctx.workerScript.scriptRef.filename}: ${str}`);
    },
  tprintf:
    (ctx: NetscriptContext) =>
    (_format: unknown, ...args: unknown[]): void => {
      const format = helpers.string(ctx, "format", _format);
      const str = vsprintf(format, args);

      if (str.startsWith("ERROR") || str.startsWith("FAIL")) {
        Terminal.error(`${str}`);
        return;
      }
      if (str.startsWith("SUCCESS")) {
        Terminal.success(`${str}`);
        return;
      }
      if (str.startsWith("WARN")) {
        Terminal.warn(`${str}`);
        return;
      }
      if (str.startsWith("INFO")) {
        Terminal.info(`${str}`);
        return;
      }
      Terminal.print(`${str}`);
    },
  clearLog: (ctx: NetscriptContext) => (): void => {
    ctx.workerScript.scriptRef.clearLog();
  },
  disableLog:
    (ctx: NetscriptContext) =>
    (_fn: unknown): void => {
      const fn = helpers.string(ctx, "fn", _fn);
      if (fn === "ALL") {
        for (const fn of Object.keys(possibleLogs)) {
          ctx.workerScript.disableLogs[fn] = true;
        }
        helpers.log(ctx, () => `Disabled logging for all functions`);
      } else if (possibleLogs[fn] === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${fn}.`);
      } else {
        ctx.workerScript.disableLogs[fn] = true;
        helpers.log(ctx, () => `Disabled logging for ${fn}`);
      }
    },
  enableLog:
    (ctx: NetscriptContext) =>
    (_fn: unknown): void => {
      const fn = helpers.string(ctx, "fn", _fn);
      if (fn === "ALL") {
        for (const fn of Object.keys(possibleLogs)) {
          delete ctx.workerScript.disableLogs[fn];
        }
        helpers.log(ctx, () => `Enabled logging for all functions`);
      } else if (possibleLogs[fn] === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${fn}.`);
      }
      delete ctx.workerScript.disableLogs[fn];
      helpers.log(ctx, () => `Enabled logging for ${fn}`);
    },
  isLogEnabled:
    (ctx: NetscriptContext) =>
    (_fn: unknown): boolean => {
      const fn = helpers.string(ctx, "fn", _fn);
      if (possibleLogs[fn] === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${fn}.`);
      }
      return !ctx.workerScript.disableLogs[fn];
    },
  getScriptLogs:
    (ctx: NetscriptContext) =>
    (scriptID: unknown, hostname: unknown, ...scriptArgs: unknown[]): string[] => {
      const ident = helpers.scriptIdentifier(ctx, scriptID, hostname, scriptArgs);
      const runningScriptObj = helpers.getRunningScript(ctx, ident);
      if (runningScriptObj == null) {
        helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
        return [];
      }

      return runningScriptObj.logs.slice();
    },
  tail:
    (ctx: NetscriptContext) =>
    (scriptID: unknown, hostname: unknown, ...scriptArgs: unknown[]): void => {
      const ident = helpers.scriptIdentifier(ctx, scriptID, hostname, scriptArgs);
      const runningScriptObj = helpers.getRunningScript(ctx, ident);
      if (runningScriptObj == null) {
        helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
        return;
      }

      LogBoxEvents.emit(runningScriptObj);
    },
  moveTail:
    (ctx: NetscriptContext) =>
    (_x: unknown, _y: unknown, _pid: unknown = ctx.workerScript.scriptRef.pid) => {
      const x = helpers.number(ctx, "x", _x);
      const y = helpers.number(ctx, "y", _y);
      const pid = helpers.number(ctx, "pid", _pid);
      LogBoxPositionEvents.emit({ pid, data: { x, y } });
    },
  resizeTail:
    (ctx: NetscriptContext) =>
    (_w: unknown, _h: unknown, _pid: unknown = ctx.workerScript.scriptRef.pid) => {
      const w = helpers.number(ctx, "w", _w);
      const h = helpers.number(ctx, "h", _h);
      const pid = helpers.number(ctx, "pid", _pid);
      LogBoxSizeEvents.emit({ pid, data: { w, h } });
    },
  closeTail:
    (ctx: NetscriptContext) =>
    (_pid: unknown = ctx.workerScript.scriptRef.pid): void => {
      const pid = helpers.number(ctx, "pid", _pid);
      //Emit an event to tell the game to close the tail window if it exists
      LogBoxCloserEvents.emit(pid);
    },
  nuke:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);

      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return false;
      }
      if (server.hasAdminRights) {
        helpers.log(ctx, () => `Already have root access to '${server.hostname}'.`);
        return true;
      }
      if (!Player.hasProgram(Programs.NukeProgram.name)) {
        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the NUKE.exe virus!");
      }
      if (server.openPortCount < server.numOpenPortsRequired) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Not enough ports opened to use NUKE.exe virus.");
      }
      server.hasAdminRights = true;
      helpers.log(ctx, () => `Executed NUKE.exe virus on '${server.hostname}' to gain root access.`);
      return true;
    },
  brutessh:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return false;
      }
      if (!Player.hasProgram(Programs.BruteSSHProgram.name)) {
        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the BruteSSH.exe program!");
      }
      if (!server.sshPortOpen) {
        helpers.log(ctx, () => `Executed BruteSSH.exe on '${server.hostname}' to open SSH port (22).`);
        server.sshPortOpen = true;
        ++server.openPortCount;
      } else {
        helpers.log(ctx, () => `SSH Port (22) already opened on '${server.hostname}'.`);
      }
      return true;
    },
  ftpcrack:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      if (hostname === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
      }
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return false;
      }
      if (!Player.hasProgram(Programs.FTPCrackProgram.name)) {
        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the FTPCrack.exe program!");
      }
      if (!server.ftpPortOpen) {
        helpers.log(ctx, () => `Executed FTPCrack.exe on '${server.hostname}' to open FTP port (21).`);
        server.ftpPortOpen = true;
        ++server.openPortCount;
      } else {
        helpers.log(ctx, () => `FTP Port (21) already opened on '${server.hostname}'.`);
      }
      return true;
    },
  relaysmtp:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      if (hostname === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
      }
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return false;
      }
      if (!Player.hasProgram(Programs.RelaySMTPProgram.name)) {
        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the relaySMTP.exe program!");
      }
      if (!server.smtpPortOpen) {
        helpers.log(ctx, () => `Executed relaySMTP.exe on '${server.hostname}' to open SMTP port (25).`);
        server.smtpPortOpen = true;
        ++server.openPortCount;
      } else {
        helpers.log(ctx, () => `SMTP Port (25) already opened on '${server.hostname}'.`);
      }
      return true;
    },
  httpworm:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      if (hostname === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument");
      }
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return false;
      }
      if (!Player.hasProgram(Programs.HTTPWormProgram.name)) {
        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the HTTPWorm.exe program!");
      }
      if (!server.httpPortOpen) {
        helpers.log(ctx, () => `Executed HTTPWorm.exe on '${server.hostname}' to open HTTP port (80).`);
        server.httpPortOpen = true;
        ++server.openPortCount;
      } else {
        helpers.log(ctx, () => `HTTP Port (80) already opened on '${server.hostname}'.`);
      }
      return true;
    },
  sqlinject:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      if (hostname === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Takes 1 argument.");
      }
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return false;
      }
      if (!Player.hasProgram(Programs.SQLInjectProgram.name)) {
        throw helpers.makeRuntimeErrorMsg(ctx, "You do not have the SQLInject.exe program!");
      }
      if (!server.sqlPortOpen) {
        helpers.log(ctx, () => `Executed SQLInject.exe on '${server.hostname}' to open SQL port (1433).`);
        server.sqlPortOpen = true;
        ++server.openPortCount;
      } else {
        helpers.log(ctx, () => `SQL Port (1433) already opened on '${server.hostname}'.`);
      }
      return true;
    },
  run:
    (ctx: NetscriptContext) =>
    (_scriptname: unknown, _threads: unknown = 1, ..._args: unknown[]): number => {
      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
      const threads = helpers.number(ctx, "threads", _threads);
      const args = helpers.scriptArgs(ctx, _args);
      if (scriptname === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: run(scriptname, [numThreads], [arg1], [arg2]...)");
      }
      if (isNaN(threads) || threads <= 0) {
        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid thread count. Must be numeric and > 0, is ${threads}`);
      }
      const scriptServer = GetServer(ctx.workerScript.hostname);
      if (scriptServer == null) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Could not find server. This is a bug. Report to dev.");
      }

      return runScriptFromScript("run", scriptServer, scriptname, args, ctx.workerScript, threads);
    },
  exec:
    (ctx: NetscriptContext) =>
    (_scriptname: unknown, _hostname: unknown, _threads: unknown = 1, ..._args: unknown[]): number => {
      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const threads = helpers.number(ctx, "threads", _threads);
      const args = helpers.scriptArgs(ctx, _args);
      if (scriptname === undefined || hostname === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: exec(scriptname, server, [numThreads], [arg1], [arg2]...)");
      }
      if (isNaN(threads) || threads <= 0) {
        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid thread count. Must be numeric and > 0, is ${threads}`);
      }
      const server = helpers.getServer(ctx, hostname);
      return runScriptFromScript("exec", server, scriptname, args, ctx.workerScript, threads);
    },
  spawn:
    (ctx: NetscriptContext) =>
    (_scriptname: unknown, _threads: unknown = 1, ..._args: unknown[]): void => {
      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
      const threads = helpers.number(ctx, "threads", _threads);
      const args = helpers.scriptArgs(ctx, _args);
      if (!scriptname || !threads) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: spawn(scriptname, threads)");
      }

      const spawnDelay = 10;
      setTimeout(() => {
        if (isNaN(threads) || threads <= 0) {
          throw helpers.makeRuntimeErrorMsg(ctx, `Invalid thread count. Must be numeric and > 0, is ${threads}`);
        }
        const scriptServer = GetServer(ctx.workerScript.hostname);
        if (scriptServer == null) {
          throw helpers.makeRuntimeErrorMsg(ctx, "Could not find server. This is a bug. Report to dev");
        }

        return runScriptFromScript("spawn", scriptServer, scriptname, args, ctx.workerScript, threads);
      }, spawnDelay * 1e3);

      helpers.log(ctx, () => `Will execute '${scriptname}' in ${spawnDelay} seconds`);

      if (killWorkerScript(ctx.workerScript)) {
        helpers.log(ctx, () => "Exiting...");
      }
    },
  kill:
    (ctx: NetscriptContext) =>
    (scriptID: unknown, hostname: unknown, ...scriptArgs: unknown[]): boolean => {
      const ident = helpers.scriptIdentifier(ctx, scriptID, hostname, scriptArgs);
      let res;
      const killByPid = typeof ident === "number";
      if (killByPid) {
        // Kill by pid
        res = killWorkerScript(ident);
      } else {
        // Kill by filename/hostname
        if (scriptID === undefined || hostname === undefined) {
          throw helpers.makeRuntimeErrorMsg(ctx, "Usage: kill(scriptname, server, [arg1], [arg2]...)");
        }

        const server = helpers.getServer(ctx, ident.hostname);
        const runningScriptObj = helpers.getRunningScriptByArgs(ctx, ident.scriptname, ident.hostname, ident.args);
        if (runningScriptObj == null) {
          helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
          return false;
        }

        res = killWorkerScript({ runningScript: runningScriptObj, hostname: server.hostname });
      }

      if (res) {
        if (killByPid) {
          helpers.log(ctx, () => `Killing script with PID ${ident}`);
        } else {
          helpers.log(ctx, () => `Killing '${scriptID}' on '${hostname}' with args: ${arrayToString(scriptArgs)}.`);
        }
        return true;
      } else {
        if (killByPid) {
          helpers.log(ctx, () => `No script with PID ${ident}`);
        } else {
          helpers.log(
            ctx,
            () => `No such script '${scriptID}' on '${hostname}' with args: ${arrayToString(scriptArgs)}`,
          );
        }
        return false;
      }
    },
  killall:
    (ctx: NetscriptContext) =>
    (_hostname: unknown = ctx.workerScript.hostname, _safetyguard: unknown = true): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const safetyguard = !!_safetyguard;
      if (hostname === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: killall(hostname, [safetyguard boolean])");
      }
      const server = helpers.getServer(ctx, hostname);

      let scriptsKilled = 0;

      for (let i = server.runningScripts.length - 1; i >= 0; --i) {
        if (safetyguard === true && server.runningScripts[i].pid == ctx.workerScript.pid) continue;
        killWorkerScript({ runningScript: server.runningScripts[i], hostname: server.hostname });
        ++scriptsKilled;
      }
      WorkerScriptStartStopEventEmitter.emit();
      helpers.log(
        ctx,
        () => `Killing all scripts on '${server.hostname}'. May take a few minutes for the scripts to die.`,
      );

      return scriptsKilled > 0;
    },
  exit: (ctx: NetscriptContext) => (): never => {
    helpers.log(ctx, () => "Exiting...");
    killWorkerScript(ctx.workerScript);
    throw new ScriptDeath(ctx.workerScript);
  },
  scp:
    (ctx: NetscriptContext) =>
    (_files: unknown, _destination: unknown, _source: unknown = ctx.workerScript.hostname): boolean => {
      const destination = helpers.string(ctx, "destination", _destination);
      const source = helpers.string(ctx, "source", _source);
      const destServer = helpers.getServer(ctx, destination);
      const sourceServ = helpers.getServer(ctx, source);
      const files = Array.isArray(_files) ? _files : [_files];

      //First loop through filenames to find all errors before moving anything.
      for (const file of files) {
        // Not a string
        if (typeof file !== "string")
          throw helpers.makeRuntimeErrorMsg(ctx, "files should be a string or an array of strings.");

        // Invalid file name
        if (!isValidFilePath(file)) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filename: '${file}'`);

        // Invalid file type
        if (!file.endsWith(".lit") && !isScriptFilename(file) && !file.endsWith("txt")) {
          throw helpers.makeRuntimeErrorMsg(ctx, "Only works for scripts, .lit and .txt files.");
        }
      }

      let noFailures = true;
      //ts detects files as any[] here even though we would have thrown in the above loop if it wasn't string[]
      for (const file of files as string[]) {
        // Scp for lit files
        if (file.endsWith(".lit")) {
          const sourceMessage = sourceServ.messages.find((message) => message === file);
          if (!sourceMessage) {
            helpers.log(ctx, () => `File '${file}' does not exist.`);
            noFailures = false;
            continue;
          }

          const destMessage = destServer.messages.find((message) => message === file);
          if (destMessage) {
            helpers.log(ctx, () => `File '${file}' was already on '${destServer?.hostname}'.`);
            continue;
          }

          destServer.messages.push(file);
          helpers.log(ctx, () => `File '${file}' copied over to '${destServer?.hostname}'.`);
          continue;
        }

        // Scp for text files
        if (file.endsWith(".txt")) {
          const sourceTextFile = sourceServ.textFiles.find((textFile) => textFile.fn === file);
          if (!sourceTextFile) {
            helpers.log(ctx, () => `File '${file}' does not exist.`);
            noFailures = false;
            continue;
          }

          const destTextFile = destServer.textFiles.find((textFile) => textFile.fn === file);
          if (destTextFile) {
            destTextFile.text = sourceTextFile.text;
            helpers.log(ctx, () => `File '${file}' overwritten on '${destServer?.hostname}'.`);
            continue;
          }

          const newFile = new TextFile(sourceTextFile.fn, sourceTextFile.text);
          destServer.textFiles.push(newFile);
          helpers.log(ctx, () => `File '${file}' copied over to '${destServer?.hostname}'.`);
          continue;
        }

        // Scp for script files
        const sourceScript = sourceServ.scripts.find((script) => script.filename === file);
        if (!sourceScript) {
          helpers.log(ctx, () => `File '${file}' does not exist.`);
          noFailures = false;
          continue;
        }

        // Overwrite script if it already exists
        const destScript = destServer.scripts.find((script) => script.filename === file);
        if (destScript) {
          if (destScript.code === sourceScript.code) {
            helpers.log(ctx, () => `Identical file '${file}' was already on '${destServer?.hostname}'`);
            continue;
          }
          destScript.code = sourceScript.code;
          destScript.ramUsage = destScript.ramUsage;
          destScript.markUpdated();
          helpers.log(ctx, () => `WARNING: File '${file}' overwritten on '${destServer?.hostname}'`);
          continue;
        }

        // Create new script if it does not already exist
        const newScript = new Script(Player, file);
        newScript.code = sourceScript.code;
        newScript.ramUsage = sourceScript.ramUsage;
        newScript.server = destServer.hostname;
        destServer.scripts.push(newScript);
        helpers.log(ctx, () => `File '${file}' copied over to '${destServer?.hostname}'.`);
        newScript.updateRamUsage(Player, destServer.scripts);
      }

      return noFailures;
    },
  ls:
    (ctx: NetscriptContext) =>
    (_hostname: unknown, _grep: unknown = ""): string[] => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const grep = helpers.string(ctx, "grep", _grep);

      const server = helpers.getServer(ctx, hostname);

      // Get the grep filter, if one exists
      let filter = "";
      if (_grep !== undefined) {
        filter = grep.toString();
      }

      const allFiles = [];
      for (let i = 0; i < server.programs.length; i++) {
        if (filter) {
          if (server.programs[i].includes(filter)) {
            allFiles.push(server.programs[i]);
          }
        } else {
          allFiles.push(server.programs[i]);
        }
      }
      for (let i = 0; i < server.scripts.length; i++) {
        if (filter) {
          if (server.scripts[i].filename.includes(filter)) {
            allFiles.push(server.scripts[i].filename);
          }
        } else {
          allFiles.push(server.scripts[i].filename);
        }
      }
      for (let i = 0; i < server.messages.length; i++) {
        if (filter) {
          const msg = server.messages[i];
          if (msg.includes(filter)) {
            allFiles.push(msg);
          }
        } else {
          allFiles.push(server.messages[i]);
        }
      }

      for (let i = 0; i < server.textFiles.length; i++) {
        if (filter) {
          if (server.textFiles[i].fn.includes(filter)) {
            allFiles.push(server.textFiles[i].fn);
          }
        } else {
          allFiles.push(server.textFiles[i].fn);
        }
      }

      for (let i = 0; i < server.contracts.length; ++i) {
        if (filter) {
          if (server.contracts[i].fn.includes(filter)) {
            allFiles.push(server.contracts[i].fn);
          }
        } else {
          allFiles.push(server.contracts[i].fn);
        }
      }

      // Sort the files alphabetically then print each
      allFiles.sort();
      return allFiles;
    },
  getRecentScripts: () => (): IRecentScript[] => {
    return recentScripts.map((rs) => ({
      timeOfDeath: rs.timeOfDeath,
      ...helpers.createPublicRunningScript(rs.runningScript),
    }));
  },
  ps:
    (ctx: NetscriptContext) =>
    (_hostname: unknown = ctx.workerScript.hostname): ProcessInfo[] => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      const processes = [];
      for (const script of server.runningScripts) {
        processes.push({
          filename: script.filename,
          threads: script.threads,
          args: script.args.slice(),
          pid: script.pid,
        });
      }
      return processes;
    },
  hasRootAccess:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);

      const server = helpers.getServer(ctx, hostname);
      return server.hasAdminRights;
    },
  getHostname: (ctx: NetscriptContext) => (): string => {
    const scriptServer = GetServer(ctx.workerScript.hostname);
    if (scriptServer == null) {
      throw helpers.makeRuntimeErrorMsg(ctx, "Could not find server. This is a bug. Report to dev.");
    }
    return scriptServer.hostname;
  },
  getHackingLevel: (ctx: NetscriptContext) => (): number => {
    Player.updateSkillLevels();
    helpers.log(ctx, () => `returned ${Player.skills.hacking}`);
    return Player.skills.hacking;
  },
  getHackingMultipliers: () => (): HackingMultipliers => {
    return {
      chance: Player.mults.hacking_chance,
      speed: Player.mults.hacking_speed,
      money: Player.mults.hacking_money,
      growth: Player.mults.hacking_grow,
    };
  },
  getHacknetMultipliers: () => (): HacknetMultipliers => {
    return {
      production: Player.mults.hacknet_node_money,
      purchaseCost: Player.mults.hacknet_node_purchase_cost,
      ramCost: Player.mults.hacknet_node_ram_cost,
      coreCost: Player.mults.hacknet_node_core_cost,
      levelCost: Player.mults.hacknet_node_level_cost,
    };
  },
  getBitNodeMultipliers: (ctx: NetscriptContext) => (): IBNMults => {
    if (Player.sourceFileLvl(5) <= 0 && Player.bitNodeN !== 5) {
      throw helpers.makeRuntimeErrorMsg(ctx, "Requires Source-File 5 to run.");
    }
    const copy = Object.assign({}, BitNodeMultipliers);
    return copy;
  },
  getServer:
    (ctx: NetscriptContext) =>
    (_hostname: unknown = ctx.workerScript.hostname): IServerDef => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      const copy = Object.assign({}, server) as Server;
      // These fields should be hidden.
      copy.contracts = [];
      copy.messages = [];
      copy.runningScripts = [];
      copy.scripts = [];
      copy.textFiles = [];
      copy.programs = [];
      copy.serversOnNetwork = [];
      if (!copy.baseDifficulty) copy.baseDifficulty = 0;
      if (!copy.hackDifficulty) copy.hackDifficulty = 0;
      if (!copy.minDifficulty) copy.minDifficulty = 0;
      if (!copy.moneyAvailable) copy.moneyAvailable = 0;
      if (!copy.moneyMax) copy.moneyMax = 0;
      if (!copy.numOpenPortsRequired) copy.numOpenPortsRequired = 0;
      if (!copy.openPortCount) copy.openPortCount = 0;
      if (!copy.requiredHackingSkill) copy.requiredHackingSkill = 0;
      if (!copy.serverGrowth) copy.serverGrowth = 0;
      return copy;
    },
  getServerMoneyAvailable:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 0;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getServerMoneyAvailable")) {
        return 0;
      }
      if (server.hostname == "home") {
        // Return player's money
        helpers.log(ctx, () => `returned player's money: ${numeralWrapper.formatMoney(Player.money)}`);
        return Player.money;
      }
      helpers.log(ctx, () => `returned ${numeralWrapper.formatMoney(server.moneyAvailable)} for '${server.hostname}'`);
      return server.moneyAvailable;
    },
  getServerSecurityLevel:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 1;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getServerSecurityLevel")) {
        return 1;
      }
      helpers.log(
        ctx,
        () => `returned ${numeralWrapper.formatServerSecurity(server.hackDifficulty)} for '${server.hostname}'`,
      );
      return server.hackDifficulty;
    },
  getServerBaseSecurityLevel:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      helpers.log(ctx, () => `getServerBaseSecurityLevel is deprecated because it's not useful.`);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 1;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getServerBaseSecurityLevel")) {
        return 1;
      }
      helpers.log(
        ctx,
        () => `returned ${numeralWrapper.formatServerSecurity(server.baseDifficulty)} for '${server.hostname}'`,
      );
      return server.baseDifficulty;
    },
  getServerMinSecurityLevel:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 1;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getServerMinSecurityLevel")) {
        return 1;
      }
      helpers.log(
        ctx,
        () => `returned ${numeralWrapper.formatServerSecurity(server.minDifficulty)} for ${server.hostname}`,
      );
      return server.minDifficulty;
    },
  getServerRequiredHackingLevel:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 1;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getServerRequiredHackingLevel")) {
        return 1;
      }
      helpers.log(
        ctx,
        () => `returned ${numeralWrapper.formatSkill(server.requiredHackingSkill)} for '${server.hostname}'`,
      );
      return server.requiredHackingSkill;
    },
  getServerMaxMoney:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 0;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getServerMaxMoney")) {
        return 0;
      }
      helpers.log(ctx, () => `returned ${numeralWrapper.formatMoney(server.moneyMax)} for '${server.hostname}'`);
      return server.moneyMax;
    },
  getServerGrowth:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 1;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getServerGrowth")) {
        return 1;
      }
      helpers.log(ctx, () => `returned ${server.serverGrowth} for '${server.hostname}'`);
      return server.serverGrowth;
    },
  getServerNumPortsRequired:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "Cannot be executed on this server.");
        return 5;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getServerNumPortsRequired")) {
        return 5;
      }
      helpers.log(ctx, () => `returned ${server.numOpenPortsRequired} for '${server.hostname}'`);
      return server.numOpenPortsRequired;
    },
  getServerRam:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): [number, number] => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      helpers.log(ctx, () => `getServerRam is deprecated in favor of getServerMaxRam / getServerUsedRam`);
      const server = helpers.getServer(ctx, hostname);
      helpers.log(
        ctx,
        () => `returned [${numeralWrapper.formatRAM(server.maxRam)}, ${numeralWrapper.formatRAM(server.ramUsed)}]`,
      );
      return [server.maxRam, server.ramUsed];
    },
  getServerMaxRam:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      helpers.log(ctx, () => `returned ${numeralWrapper.formatRAM(server.maxRam)}`);
      return server.maxRam;
    },
  getServerUsedRam:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      helpers.log(ctx, () => `returned ${numeralWrapper.formatRAM(server.ramUsed)}`);
      return server.ramUsed;
    },
  serverExists:
    (ctx: NetscriptContext) =>
    (_hostname: unknown): boolean => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      return GetServer(hostname) !== null;
    },
  fileExists:
    (ctx: NetscriptContext) =>
    (_filename: unknown, _hostname: unknown = ctx.workerScript.hostname): boolean => {
      const filename = helpers.string(ctx, "filename", _filename);
      const hostname = helpers.string(ctx, "hostname", _hostname);
      if (filename === undefined) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Usage: fileExists(scriptname, [server])");
      }
      const server = helpers.getServer(ctx, hostname);
      for (let i = 0; i < server.scripts.length; ++i) {
        if (filename == server.scripts[i].filename) {
          return true;
        }
      }
      for (let i = 0; i < server.programs.length; ++i) {
        if (filename.toLowerCase() == server.programs[i].toLowerCase()) {
          return true;
        }
      }
      for (let i = 0; i < server.messages.length; ++i) {
        if (filename.toLowerCase() === server.messages[i].toLowerCase()) {
          return true;
        }
      }
      const txtFile = getTextFile(filename, server);
      return txtFile != null;
    },
  isRunning:
    (ctx: NetscriptContext) =>
    (fn: unknown, hostname: unknown, ...scriptArgs: unknown[]): boolean => {
      const ident = helpers.scriptIdentifier(ctx, fn, hostname, scriptArgs);
      return helpers.getRunningScript(ctx, ident) !== null;
    },
  getPurchasedServerLimit: () => (): number => {
    return getPurchaseServerLimit();
  },
  getPurchasedServerMaxRam: () => (): number => {
    return getPurchaseServerMaxRam();
  },
  getPurchasedServerCost:
    (ctx: NetscriptContext) =>
    (_ram: unknown): number => {
      const ram = helpers.number(ctx, "ram", _ram);

      const cost = getPurchaseServerCost(ram);
      if (cost === Infinity) {
        helpers.log(ctx, () => `Invalid argument: ram='${ram}'`);
        return Infinity;
      }

      return cost;
    },
  purchaseServer:
    (ctx: NetscriptContext) =>
    (_name: unknown, _ram: unknown): string => {
      const name = helpers.string(ctx, "name", _name);
      const ram = helpers.number(ctx, "ram", _ram);
      let hostnameStr = String(name);
      hostnameStr = hostnameStr.replace(/\s+/g, "");
      if (hostnameStr == "") {
        helpers.log(ctx, () => `Invalid argument: hostname='${hostnameStr}'`);
        return "";
      }

      if (Player.purchasedServers.length >= getPurchaseServerLimit()) {
        helpers.log(
          ctx,
          () =>
            `You have reached the maximum limit of ${getPurchaseServerLimit()} servers. You cannot purchase any more.`,
        );
        return "";
      }

      const cost = getPurchaseServerCost(ram);
      if (cost === Infinity) {
        if (ram > getPurchaseServerMaxRam()) {
          helpers.log(ctx, () => `Invalid argument: ram='${ram}' must not be greater than getPurchaseServerMaxRam`);
        } else {
          helpers.log(ctx, () => `Invalid argument: ram='${ram}' must be a positive power of 2`);
        }

        return "";
      }

      if (Player.money < cost) {
        helpers.log(ctx, () => `Not enough money to purchase server. Need ${numeralWrapper.formatMoney(cost)}`);
        return "";
      }
      const newServ = safetlyCreateUniqueServer({
        ip: createUniqueRandomIp(),
        hostname: hostnameStr,
        organizationName: "",
        isConnectedTo: false,
        adminRights: true,
        purchasedByPlayer: true,
        maxRam: ram,
      });
      AddToAllServers(newServ);

      Player.purchasedServers.push(newServ.hostname);
      const homeComputer = Player.getHomeComputer();
      homeComputer.serversOnNetwork.push(newServ.hostname);
      newServ.serversOnNetwork.push(homeComputer.hostname);
      Player.loseMoney(cost, "servers");
      helpers.log(
        ctx,
        () => `Purchased new server with hostname '${newServ.hostname}' for ${numeralWrapper.formatMoney(cost)}`,
      );
      return newServ.hostname;
    },
  deleteServer:
    (ctx: NetscriptContext) =>
    (_name: unknown): boolean => {
      const name = helpers.string(ctx, "name", _name);
      let hostnameStr = String(name);
      hostnameStr = hostnameStr.replace(/\s\s+/g, "");
      const server = GetServer(hostnameStr);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => `Invalid argument: hostname='${hostnameStr}'`);
        return false;
      }

      if (!server.purchasedByPlayer || server.hostname === "home") {
        helpers.log(ctx, () => "Cannot delete non-purchased server.");
        return false;
      }

      const hostname = server.hostname;

      // Can't delete server you're currently connected to
      if (server.isConnectedTo) {
        helpers.log(ctx, () => "You are currently connected to the server you are trying to delete.");
        return false;
      }

      // A server cannot delete itself
      if (hostname === ctx.workerScript.hostname) {
        helpers.log(ctx, () => "Cannot delete the server this script is running on.");
        return false;
      }

      // Delete all scripts running on server
      if (server.runningScripts.length > 0) {
        helpers.log(ctx, () => `Cannot delete server '${hostname}' because it still has scripts running.`);
        return false;
      }

      // Delete from player's purchasedServers array
      let found = false;
      for (let i = 0; i < Player.purchasedServers.length; ++i) {
        if (hostname == Player.purchasedServers[i]) {
          found = true;
          Player.purchasedServers.splice(i, 1);
          break;
        }
      }

      if (!found) {
        helpers.log(
          ctx,
          () => `Could not identify server ${hostname} as a purchased server. This is a bug. Report to dev.`,
        );
        return false;
      }

      // Delete from all servers
      DeleteServer(hostname);

      // Delete from home computer
      found = false;
      const homeComputer = Player.getHomeComputer();
      for (let i = 0; i < homeComputer.serversOnNetwork.length; ++i) {
        if (hostname == homeComputer.serversOnNetwork[i]) {
          homeComputer.serversOnNetwork.splice(i, 1);
          helpers.log(ctx, () => `Deleted server '${hostnameStr}`);
          return true;
        }
      }
      // Wasn't found on home computer
      helpers.log(ctx, () => `Could not find server ${hostname} as a purchased server. This is a bug. Report to dev.`);
      return false;
    },
  getPurchasedServers: () => (): string[] => {
    const res: string[] = [];
    Player.purchasedServers.forEach(function (hostname) {
      res.push(hostname);
    });
    return res;
  },
  writePort:
    (ctx: NetscriptContext) =>
    (_port: unknown, data: unknown = ""): Promise<any> => {
      const port = helpers.number(ctx, "port", _port);
      if (typeof data !== "string" && typeof data !== "number") {
        throw helpers.makeRuntimeErrorMsg(
          ctx,
          `Trying to write invalid data to a port: only strings and numbers are valid.`,
        );
      }
      const iport = helpers.getValidPort(ctx, port);
      return Promise.resolve(iport.write(data));
    },
  write:
    (ctx: NetscriptContext) =>
    (_filename: unknown, _data: unknown = "", _mode: unknown = "a"): void => {
      let fn = helpers.string(ctx, "handle", _filename);
      const data = helpers.string(ctx, "data", _data);
      const mode = helpers.string(ctx, "mode", _mode);
      if (!isValidFilePath(fn)) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filepath: ${fn}`);

      if (fn.lastIndexOf("/") === 0) fn = removeLeadingSlash(fn);

      const server = helpers.getServer(ctx, ctx.workerScript.hostname);

      if (isScriptFilename(fn)) {
        // Write to script
        let script = ctx.workerScript.getScriptOnServer(fn, server);
        if (script == null) {
          // Create a new script
          script = new Script(Player, fn, String(data), server.hostname, server.scripts);
          server.scripts.push(script);
          return script.updateRamUsage(Player, server.scripts);
        }
        mode === "w" ? (script.code = String(data)) : (script.code += data);
        return script.updateRamUsage(Player, server.scripts);
      } else {
        // Write to text file
        if (!fn.endsWith(".txt")) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filename: ${fn}`);
        const txtFile = getTextFile(fn, server);
        if (txtFile == null) {
          createTextFile(fn, String(data), server);
          return;
        }
        if (mode === "w") {
          txtFile.write(String(data));
        } else {
          txtFile.append(String(data));
        }
      }
      return;
    },
  tryWritePort:
    (ctx: NetscriptContext) =>
    (_port: unknown, data: unknown = ""): Promise<any> => {
      const port = helpers.number(ctx, "port", _port);
      if (typeof data !== "string" && typeof data !== "number") {
        throw helpers.makeRuntimeErrorMsg(
          ctx,
          `Trying to write invalid data to a port: only strings and numbers are valid.`,
        );
      }
      const iport = helpers.getValidPort(ctx, port);
      return Promise.resolve(iport.tryWrite(data));
    },
  readPort:
    (ctx: NetscriptContext) =>
    (_port: unknown): unknown => {
      const port = helpers.number(ctx, "port", _port);
      // Read from port
      const iport = helpers.getValidPort(ctx, port);
      const x = iport.read();
      return x;
    },
  read:
    (ctx: NetscriptContext) =>
    (_filename: unknown): string => {
      const fn = helpers.string(ctx, "filename", _filename);
      const server = GetServer(ctx.workerScript.hostname);
      if (server == null) {
        throw helpers.makeRuntimeErrorMsg(ctx, "Error getting Server. This is a bug. Report to dev.");
      }
      if (isScriptFilename(fn)) {
        // Read from script
        const script = ctx.workerScript.getScriptOnServer(fn, server);
        if (script == null) {
          return "";
        }
        return script.code;
      } else {
        // Read from text file
        const txtFile = getTextFile(fn, server);
        if (txtFile !== null) {
          return txtFile.text;
        } else {
          return "";
        }
      }
    },
  peek:
    (ctx: NetscriptContext) =>
    (_port: unknown): unknown => {
      const port = helpers.number(ctx, "port", _port);
      const iport = helpers.getValidPort(ctx, port);
      const x = iport.peek();
      return x;
    },
  clear:
    (ctx: NetscriptContext) =>
    (_file: unknown): void => {
      const file = helpers.string(ctx, "file", _file);
      if (isString(file)) {
        // Clear text file
        const fn = file;
        const server = GetServer(ctx.workerScript.hostname);
        if (server == null) {
          throw helpers.makeRuntimeErrorMsg(ctx, "Error getting Server. This is a bug. Report to dev.");
        }
        const txtFile = getTextFile(fn, server);
        if (txtFile != null) {
          txtFile.write("");
        }
      } else {
        throw helpers.makeRuntimeErrorMsg(ctx, `Invalid argument: ${file}`);
      }
    },
  clearPort:
    (ctx: NetscriptContext) =>
    (_port: unknown): void => {
      const port = helpers.number(ctx, "port", _port);
      // Clear port
      const iport = helpers.getValidPort(ctx, port);
      iport.clear();
    },
  getPortHandle:
    (ctx: NetscriptContext) =>
    (_port: unknown): IPort => {
      const port = helpers.number(ctx, "port", _port);
      const iport = helpers.getValidPort(ctx, port);
      return iport;
    },
  rm:
    (ctx: NetscriptContext) =>
    (_fn: unknown, _hostname: unknown = ctx.workerScript.hostname): boolean => {
      const fn = helpers.string(ctx, "fn", _fn);
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const s = helpers.getServer(ctx, hostname);

      const status = s.removeFile(fn);
      if (!status.res) {
        helpers.log(ctx, () => status.msg + "");
      }

      return status.res;
    },
  scriptRunning:
    (ctx: NetscriptContext) =>
    (_scriptname: unknown, _hostname: unknown): boolean => {
      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      for (let i = 0; i < server.runningScripts.length; ++i) {
        if (server.runningScripts[i].filename == scriptname) {
          return true;
        }
      }
      return false;
    },
  scriptKill:
    (ctx: NetscriptContext) =>
    (_scriptname: unknown, _hostname: unknown): boolean => {
      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      let suc = false;
      for (let i = 0; i < server.runningScripts.length; i++) {
        if (server.runningScripts[i].filename == scriptname) {
          killWorkerScript({ runningScript: server.runningScripts[i], hostname: server.hostname });
          suc = true;
          i--;
        }
      }
      return suc;
    },
  getScriptName: (ctx: NetscriptContext) => (): string => {
    return ctx.workerScript.name;
  },
  getScriptRam:
    (ctx: NetscriptContext) =>
    (_scriptname: unknown, _hostname: unknown = ctx.workerScript.hostname): number => {
      const scriptname = helpers.string(ctx, "scriptname", _scriptname);
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      for (let i = 0; i < server.scripts.length; ++i) {
        if (server.scripts[i].filename == scriptname) {
          return server.scripts[i].ramUsage;
        }
      }
      return 0;
    },
  getRunningScript:
    (ctx: NetscriptContext) =>
    (fn: unknown, hostname: unknown, ...args: unknown[]): IRunningScriptDef | null => {
      const ident = helpers.scriptIdentifier(ctx, fn, hostname, args);
      const runningScript = helpers.getRunningScript(ctx, ident);
      if (runningScript === null) return null;
      return helpers.createPublicRunningScript(runningScript);
    },
  getHackTime:
    (ctx: NetscriptContext) =>
    (_hostname: unknown = ctx.workerScript.hostname): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "invalid for this kind of server");
        return Infinity;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getHackTime")) {
        return Infinity;
      }

      return calculateHackingTime(server, Player) * 1000;
    },
  getGrowTime:
    (ctx: NetscriptContext) =>
    (_hostname: unknown = ctx.workerScript.hostname): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "invalid for this kind of server");
        return Infinity;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getGrowTime")) {
        return Infinity;
      }

      return calculateGrowTime(server, Player) * 1000;
    },
  getWeakenTime:
    (ctx: NetscriptContext) =>
    (_hostname: unknown = ctx.workerScript.hostname): number => {
      const hostname = helpers.string(ctx, "hostname", _hostname);
      const server = helpers.getServer(ctx, hostname);
      if (!(server instanceof Server)) {
        helpers.log(ctx, () => "invalid for this kind of server");
        return Infinity;
      }
      if (helpers.failOnHacknetServer(ctx, server, "getWeakenTime")) {
        return Infinity;
      }

      return calculateWeakenTime(server, Player) * 1000;
    },
  getTotalScriptIncome: () => (): [number, number] => {
    // First element is total income of all currently running scripts
    let total = 0;
    for (const script of workerScripts.values()) {
      total += script.scriptRef.onlineMoneyMade / script.scriptRef.onlineRunningTime;
    }

    return [total, Player.scriptProdSinceLastAug / (Player.playtimeSinceLastAug / 1000)];
  },
  getScriptIncome:
    (ctx: NetscriptContext) =>
    (fn: unknown, hostname: unknown, ...args: unknown[]): number => {
      const ident = helpers.scriptIdentifier(ctx, fn, hostname, args);
      const runningScript = helpers.getRunningScript(ctx, ident);
      if (runningScript == null) {
        helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
        return -1;
      }
      return runningScript.onlineMoneyMade / runningScript.onlineRunningTime;
    },
  getTotalScriptExpGain: () => (): number => {
    let total = 0;
    for (const ws of workerScripts.values()) {
      total += ws.scriptRef.onlineExpGained / ws.scriptRef.onlineRunningTime;
    }
    return total;
  },
  getScriptExpGain:
    (ctx: NetscriptContext) =>
    (fn: unknown, hostname: unknown, ...args: unknown[]): number => {
      const ident = helpers.scriptIdentifier(ctx, fn, hostname, args);
      const runningScript = helpers.getRunningScript(ctx, ident);
      if (runningScript == null) {
        helpers.log(ctx, () => helpers.getCannotFindRunningScriptErrorMessage(ident));
        return -1;
      }
      return runningScript.onlineExpGained / runningScript.onlineRunningTime;
    },
  nFormat:
    (ctx: NetscriptContext) =>
    (_n: unknown, _format: unknown): string => {
      const n = helpers.number(ctx, "n", _n);
      const format = helpers.string(ctx, "format", _format);
      if (isNaN(n)) {
        return "";
      }

      return numeralWrapper.format(n, format);
    },
  tFormat:
    (ctx: NetscriptContext) =>
    (_milliseconds: unknown, _milliPrecision: unknown = false): string => {
      const milliseconds = helpers.number(ctx, "milliseconds", _milliseconds);
      const milliPrecision = !!_milliPrecision;
      return convertTimeMsToTimeElapsedString(milliseconds, milliPrecision);
    },
  getTimeSinceLastAug: () => (): number => {
    return Player.playtimeSinceLastAug;
  },
  alert:
    (ctx: NetscriptContext) =>
    (_message: unknown): void => {
      const message = helpers.string(ctx, "message", _message);
      dialogBoxCreate(message);
    },
  toast:
    (ctx: NetscriptContext) =>
    (_message: unknown, _variant: unknown = ToastVariant.SUCCESS, _duration: unknown = 2000): void => {
      const message = helpers.string(ctx, "message", _message);
      const variant = helpers.string(ctx, "variant", _variant);
      const duration = _duration === null ? null : helpers.number(ctx, "duration", _duration);
      if (!checkEnum(ToastVariant, variant))
        throw new Error(`variant must be one of ${Object.values(ToastVariant).join(", ")}`);
      SnackbarEvents.emit(message, variant, duration);
    },
  prompt:
    (ctx: NetscriptContext) =>
    (_txt: unknown, options?: { type?: string; options?: string[] }): Promise<boolean | string> => {
      const txt = helpers.string(ctx, "txt", _txt);

      return new Promise(function (resolve) {
        PromptEvent.emit({
          txt: txt,
          options,
          resolve: resolve,
        });
      });
    },
  wget:
    (ctx: NetscriptContext) =>
    async (_url: unknown, _target: unknown, _hostname: unknown = ctx.workerScript.hostname): Promise<boolean> => {
      const url = helpers.string(ctx, "url", _url);
      const target = helpers.string(ctx, "target", _target);
      const hostname = helpers.string(ctx, "hostname", _hostname);
      if (!isScriptFilename(target) && !target.endsWith(".txt")) {
        helpers.log(ctx, () => `Invalid target file: '${target}'. Must be a script or text file.`);
        return Promise.resolve(false);
      }
      const s = helpers.getServer(ctx, hostname);
      return new Promise(function (resolve) {
        $.get(
          url,
          function (data) {
            let res;
            if (isScriptFilename(target)) {
              res = s.writeToScriptFile(Player, target, data);
            } else {
              res = s.writeToTextFile(target, data);
            }
            if (!res.success) {
              helpers.log(ctx, () => "Failed.");
              return resolve(false);
            }
            if (res.overwritten) {
              helpers.log(ctx, () => `Successfully retrieved content and overwrote '${target}' on '${hostname}'`);
              return resolve(true);
            }
            helpers.log(ctx, () => `Successfully retrieved content to new file '${target}' on '${hostname}'`);
            return resolve(true);
          },
          "text",
        ).fail(function (e) {
          helpers.log(ctx, () => JSON.stringify(e));
          return resolve(false);
        });
      });
    },
  getFavorToDonate: () => (): number => {
    return Math.floor(CONSTANTS.BaseFavorToDonate * BitNodeMultipliers.RepToDonateToFaction);
  },
  getPlayer: () => (): INetscriptPlayer => {
    const data = {
      hp: JSON.parse(JSON.stringify(Player.hp)),
      skills: JSON.parse(JSON.stringify(Player.skills)),
      exp: JSON.parse(JSON.stringify(Player.exp)),
      mults: JSON.parse(JSON.stringify(Player.mults)),
      numPeopleKilled: Player.numPeopleKilled,
      money: Player.money,
      city: Player.city,
      location: Player.location,
      bitNodeN: Player.bitNodeN,
      totalPlaytime: Player.totalPlaytime,
      playtimeSinceLastAug: Player.playtimeSinceLastAug,
      playtimeSinceLastBitnode: Player.playtimeSinceLastBitnode,
      jobs: {},
      factions: Player.factions.slice(),
      tor: Player.hasTorRouter(),
      inBladeburner: Player.inBladeburner(),
      hasCorporation: Player.hasCorporation(),
      entropy: Player.entropy,
    };
    Object.assign(data.jobs, Player.jobs);
    return data;
  },
  atExit:
    (ctx: NetscriptContext) =>
    (f: unknown): void => {
      if (typeof f !== "function") {
        throw helpers.makeRuntimeErrorMsg(ctx, "argument should be function");
      }
      ctx.workerScript.atExit = () => {
        f();
      }; // Wrap the user function to prevent WorkerScript leaking as 'this'
    },
  mv:
    (ctx: NetscriptContext) =>
    (_host: unknown, _source: unknown, _destination: unknown): void => {
      const host = helpers.string(ctx, "host", _host);
      const source = helpers.string(ctx, "source", _source);
      const destination = helpers.string(ctx, "destination", _destination);

      if (!isValidFilePath(source)) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filename: '${source}'`);
      if (!isValidFilePath(destination)) throw helpers.makeRuntimeErrorMsg(ctx, `Invalid filename: '${destination}'`);

      const source_is_txt = source.endsWith(".txt");
      const dest_is_txt = destination.endsWith(".txt");

      if (!isScriptFilename(source) && !source_is_txt)
        throw helpers.makeRuntimeErrorMsg(ctx, `'mv' can only be used on scripts and text files (.txt)`);
      if (source_is_txt != dest_is_txt)
        throw helpers.makeRuntimeErrorMsg(ctx, `Source and destination files must have the same type`);

      if (source === destination) {
        return;
      }

      const destServer = helpers.getServer(ctx, host);

      if (!source_is_txt && destServer.isRunning(source))
        throw helpers.makeRuntimeErrorMsg(ctx, `Cannot use 'mv' on a script that is running`);

      interface File {
        filename: string;
      }

      const files = source_is_txt ? destServer.textFiles : destServer.scripts;
      let source_file: File | null = null;
      let dest_file: File | null = null;

      for (let i = 0; i < files.length; ++i) {
        const file = files[i];
        if (file.filename === source) {
          source_file = file;
        } else if (file.filename === destination) {
          dest_file = file;
        }
      }

      if (source_file == null) throw helpers.makeRuntimeErrorMsg(ctx, `Source file ${source} does not exist`);

      if (dest_file != null) {
        if (dest_file instanceof TextFile && source_file instanceof TextFile) {
          dest_file.text = source_file.text;
        } else if (dest_file instanceof Script && source_file instanceof Script) {
          dest_file.code = source_file.code;
          dest_file.markUpdated();
        }

        destServer.removeFile(source);
      } else {
        source_file.filename = destination;
        if (source_file instanceof Script) {
          source_file.markUpdated();
        }
      }
    },
  flags: Flags,
};

// add undocumented functions
const ns = {
  ...base,
  ...NetscriptExtra(),
};

const possibleLogs = Object.fromEntries([...helpers.getFunctionNames(ns, "")].map((a) => [a, true]));