mirror of
https://github.com/bitburner-official/bitburner-src.git
synced 2024-09-21 13:20:56 +02:00
2295 lines
92 KiB
JavaScript
2295 lines
92 KiB
JavaScript
import {substituteAliases, printAliases,
|
|
parseAliasDeclaration,
|
|
removeAlias, GlobalAliases,
|
|
Aliases} from "./Alias";
|
|
import {CodingContract, CodingContractResult,
|
|
CodingContractRewardType} from "./CodingContracts";
|
|
import {CONSTANTS} from "./Constants";
|
|
import { Programs } from "./Programs/Programs";
|
|
import { executeDarkwebTerminalCommand,
|
|
checkIfConnectedToDarkweb } from "./DarkWeb/DarkWeb";
|
|
import { DarkWebItems } from "./DarkWeb/DarkWebItems";
|
|
import {Engine} from "./engine";
|
|
import { parseFconfSettings,
|
|
createFconf } from "./Fconf/Fconf";
|
|
import { FconfSettings } from "./Fconf/FconfSettings";
|
|
import {calculateHackingChance,
|
|
calculateHackingExpGain,
|
|
calculatePercentMoneyHacked,
|
|
calculateHackingTime,
|
|
calculateGrowTime,
|
|
calculateWeakenTime} from "./Hacking";
|
|
import {TerminalHelpText, HelpTexts} from "./HelpText";
|
|
import {iTutorialNextStep, iTutorialSteps,
|
|
ITutorial} from "./InteractiveTutorial";
|
|
import {showLiterature} from "./Literature";
|
|
import { Message } from "./Message/Message";
|
|
import { showMessage } from "./Message/MessageHelpers";
|
|
import {killWorkerScript, addWorkerScript} from "./NetscriptWorker";
|
|
import {Player} from "./Player";
|
|
import {hackWorldDaemon} from "./RedPill";
|
|
import { RunningScript } from "./Script/RunningScript";
|
|
import { findRunningScript } from "./Script/ScriptHelpers";
|
|
import { isScriptFilename } from "./Script/ScriptHelpersTS";
|
|
import { AllServers } from "./Server/AllServers";
|
|
import { Server } from "./Server/Server";
|
|
import { GetServerByHostname,
|
|
getServer,
|
|
getServerOnNetwork } from "./Server/ServerHelpers";
|
|
import {Settings} from "./Settings/Settings";
|
|
import { SpecialServerIps,
|
|
SpecialServerNames } from "./Server/SpecialServerIps";
|
|
import {getTextFile} from "./TextFile";
|
|
import { setTimeoutRef } from "./utils/SetTimeoutRef";
|
|
import {containsAllStrings,
|
|
longestCommonStart} from "../utils/StringHelperFunctions";
|
|
import {Page, routing} from "./ui/navigationTracking";
|
|
import {numeralWrapper} from "./ui/numeralFormat";
|
|
import {KEY} from "../utils/helpers/keyCodes";
|
|
import {addOffset} from "../utils/helpers/addOffset";
|
|
import {isString} from "../utils/helpers/isString";
|
|
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,
|
|
postError,
|
|
hackProgressBarPost,
|
|
hackProgressPost } from "./ui/postToTerminal";
|
|
|
|
import autosize from 'autosize';
|
|
import * as JSZip from 'jszip';
|
|
import * as FileSaver from 'file-saver';
|
|
|
|
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));
|
|
}
|
|
|
|
//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
|
|
var command = terminalInput.value;
|
|
post(
|
|
"<span class='prompt'>[" +
|
|
(FconfSettings.ENABLE_TIMESTAMPS ? getTimestamp() + " " : "") +
|
|
Player.getCurrentServer().hostname +
|
|
" ~]></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; }, 0);
|
|
}
|
|
|
|
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;}
|
|
var 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, ' ');
|
|
|
|
var commandArray = input.split(" ");
|
|
var index = commandArray.length - 2;
|
|
if (index < -1) {index = 0;}
|
|
var allPos = determineAllPossibilitiesForTabCompletion(input, index);
|
|
if (allPos.length == 0) {return;}
|
|
|
|
var arg = "";
|
|
var 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;
|
|
}
|
|
}
|
|
})
|
|
|
|
//Implements a tab completion feature for terminal
|
|
// command - Terminal command except for the last incomplete argument
|
|
// arg - Incomplete argument string that the function will try to complete, or will display
|
|
// a series of possible options for
|
|
// allPossibilities - Array of strings containing all possibilities that the
|
|
// string can complete to
|
|
// index - index of argument that is being "tab completed". By default is 0, the first argument
|
|
function tabCompletion(command, arg, allPossibilities, index=0) {
|
|
if (!(allPossibilities.constructor === Array)) {return;}
|
|
if (!containsAllStrings(allPossibilities)) {return;}
|
|
|
|
//if (!command.startsWith("./")) {
|
|
//command = command.toLowerCase();
|
|
//}
|
|
|
|
//Remove all options in allPossibilities that do not match the current string
|
|
//that we are attempting to autocomplete
|
|
if (arg == "") {
|
|
for (var i = allPossibilities.length-1; i >= 0; --i) {
|
|
if (!allPossibilities[i].toLowerCase().startsWith(command.toLowerCase())) {
|
|
allPossibilities.splice(i, 1);
|
|
}
|
|
}
|
|
} else {
|
|
for (var i = allPossibilities.length-1; i >= 0; --i) {
|
|
if (!allPossibilities[i].toLowerCase().startsWith(arg.toLowerCase())) {
|
|
allPossibilities.splice(i, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
const textBox = document.getElementById("terminal-input-text-box");
|
|
if (textBox == null) {
|
|
console.warn(`Couldn't find terminal input DOM element (id=terminal-input-text-box) when trying to autocomplete`);
|
|
return;
|
|
}
|
|
const oldValue = textBox.value;
|
|
const semiColonIndex = oldValue.lastIndexOf(";");
|
|
|
|
var val = "";
|
|
if (allPossibilities.length == 0) {
|
|
return;
|
|
} else if (allPossibilities.length == 1) {
|
|
if (arg == "") {
|
|
//Autocomplete command
|
|
val = allPossibilities[0] + " ";
|
|
} else {
|
|
val = command + " " + allPossibilities[0];
|
|
}
|
|
|
|
if (semiColonIndex === -1) {
|
|
// no ; replace the whole thing.
|
|
textBox.value = val;
|
|
} else {
|
|
// replace just after the last semicolon
|
|
textBox.value = textBox.value.slice(0, semiColonIndex+1)+" "+val;
|
|
}
|
|
|
|
textBox.focus();
|
|
} else {
|
|
var longestStartSubstr = longestCommonStart(allPossibilities);
|
|
//If the longest common starting substring of remaining possibilities is the same
|
|
//as whatevers already in terminal, just list all possible options. Otherwise,
|
|
//change the input in the terminal to the longest common starting substr
|
|
var allOptionsStr = "";
|
|
for (var i = 0; i < allPossibilities.length; ++i) {
|
|
allOptionsStr += allPossibilities[i];
|
|
allOptionsStr += " ";
|
|
}
|
|
if (arg == "") {
|
|
if (longestStartSubstr == command) {
|
|
post("> " + command);
|
|
post(allOptionsStr);
|
|
} else {
|
|
if (semiColonIndex === -1) {
|
|
// No ; just replace the whole thing
|
|
textBox.value = longestStartSubstr;
|
|
} else {
|
|
// Multiple commands, so only replace after the last semicolon
|
|
textBox.value = textBox.value.slice(0, semiColonIndex + 1) + " " + longestStartSubstr;
|
|
}
|
|
|
|
textBox.focus();
|
|
}
|
|
} else {
|
|
if (longestStartSubstr == arg) {
|
|
//List all possible options
|
|
post("> " + command + " " + arg);
|
|
post(allOptionsStr);
|
|
} else {
|
|
if (semiColonIndex == -1) {
|
|
// No ; so just replace the whole thing
|
|
textBox.value = command + " " + longestStartSubstr;
|
|
} else {
|
|
// Multiple commands, so only replace after the last semiclon
|
|
textBox.value = textBox.value.slice(0, semiColonIndex + 1) + " " + command + " " + longestStartSubstr;
|
|
}
|
|
|
|
textBox.focus();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
function determineAllPossibilitiesForTabCompletion(input, index=0) {
|
|
var allPos = [];
|
|
allPos = allPos.concat(Object.keys(GlobalAliases));
|
|
var currServ = Player.getCurrentServer();
|
|
input = input.toLowerCase();
|
|
|
|
//If the command starts with './' and the index == -1, then the user
|
|
//has input ./partialexecutablename so autocomplete the script or program
|
|
//Put './' in front of each script/executable
|
|
if (input.startsWith("./") && index == -1) {
|
|
//All programs and scripts
|
|
for (var i = 0; i < currServ.scripts.length; ++i) {
|
|
allPos.push("./" + currServ.scripts[i].filename);
|
|
}
|
|
|
|
//Programs are on home computer
|
|
var homeComputer = Player.getHomeComputer();
|
|
for(var i = 0; i < homeComputer.programs.length; ++i) {
|
|
allPos.push("./" + homeComputer.programs[i]);
|
|
}
|
|
return allPos;
|
|
}
|
|
|
|
//Autocomplete the command
|
|
if (index == -1) {
|
|
return ["alias", "analyze", "cat", "check", "clear", "cls", "connect", "download", "expr",
|
|
"free", "hack", "help", "home", "hostname", "ifconfig", "kill", "killall",
|
|
"ls", "lscpu", "mem", "nano", "ps", "rm", "run", "scan", "scan-analyze",
|
|
"scp", "sudov", "tail", "theme", "top"].concat(Object.keys(Aliases)).concat(Object.keys(GlobalAliases));
|
|
}
|
|
|
|
if (input.startsWith ("buy ")) {
|
|
let options = [];
|
|
for(const i in DarkWebItems) {
|
|
const item = DarkWebItems[i]
|
|
options.push(item.program);
|
|
}
|
|
return options.concat(Object.keys(GlobalAliases));
|
|
}
|
|
|
|
if (input.startsWith("scp ") && index == 1) {
|
|
for (var iphostname in AllServers) {
|
|
if (AllServers.hasOwnProperty(iphostname)) {
|
|
allPos.push(AllServers[iphostname].ip);
|
|
allPos.push(AllServers[iphostname].hostname);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (input.startsWith("scp ") && index == 0) {
|
|
//All Scripts and lit files
|
|
for (var i = 0; i < currServ.scripts.length; ++i) {
|
|
allPos.push(currServ.scripts[i].filename);
|
|
}
|
|
for (var i = 0; i < currServ.messages.length; ++i) {
|
|
if (!(currServ.messages[i] instanceof Message)) {
|
|
allPos.push(currServ.messages[i]);
|
|
}
|
|
}
|
|
for (var i = 0; i < currServ.textFiles.length; ++i) {
|
|
allPos.push(currServ.textFiles[i].fn);
|
|
}
|
|
}
|
|
|
|
if (input.startsWith("connect ") || input.startsWith("telnet ")) {
|
|
//All network connections
|
|
for (var i = 0; i < currServ.serversOnNetwork.length; ++i) {
|
|
var serv = AllServers[currServ.serversOnNetwork[i]];
|
|
if (serv == null) {continue;}
|
|
allPos.push(serv.ip); //IP
|
|
allPos.push(serv.hostname); //Hostname
|
|
}
|
|
return allPos;
|
|
}
|
|
|
|
if (input.startsWith("kill ") || input.startsWith("tail ") ||
|
|
input.startsWith("mem ") || input.startsWith("check ")) {
|
|
//All Scripts
|
|
for (var i = 0; i < currServ.scripts.length; ++i) {
|
|
allPos.push(currServ.scripts[i].filename);
|
|
}
|
|
return allPos;
|
|
}
|
|
|
|
if (input.startsWith("nano ")) {
|
|
//Scripts and text files and .fconf
|
|
for (var i = 0; i < currServ.scripts.length; ++i) {
|
|
allPos.push(currServ.scripts[i].filename);
|
|
}
|
|
for (var i = 0; i < currServ.textFiles.length; ++i) {
|
|
allPos.push(currServ.textFiles[i].fn);
|
|
}
|
|
allPos.push(".fconf");
|
|
return allPos;
|
|
}
|
|
|
|
if (input.startsWith("rm ")) {
|
|
for (let i = 0; i < currServ.scripts.length; ++i) {
|
|
allPos.push(currServ.scripts[i].filename);
|
|
}
|
|
for (let i = 0; i < currServ.programs.length; ++i) {
|
|
allPos.push(currServ.programs[i]);
|
|
}
|
|
for (let i = 0; i < currServ.messages.length; ++i) {
|
|
if (!(currServ.messages[i] instanceof Message) && isString(currServ.messages[i]) &&
|
|
currServ.messages[i].endsWith(".lit")) {
|
|
allPos.push(currServ.messages[i]);
|
|
}
|
|
}
|
|
for (let i = 0; i < currServ.textFiles.length; ++i) {
|
|
allPos.push(currServ.textFiles[i].fn);
|
|
}
|
|
for (let i = 0; i < currServ.contracts.length; ++i) {
|
|
allPos.push(currServ.contracts[i].fn);
|
|
}
|
|
return allPos;
|
|
}
|
|
|
|
if (input.startsWith("run ")) {
|
|
//All programs, scripts, and contracts
|
|
for (let i = 0; i < currServ.scripts.length; ++i) {
|
|
allPos.push(currServ.scripts[i].filename);
|
|
}
|
|
|
|
//Programs are on home computer
|
|
var homeComputer = Player.getHomeComputer();
|
|
for (let i = 0; i < homeComputer.programs.length; ++i) {
|
|
allPos.push(homeComputer.programs[i]);
|
|
}
|
|
|
|
for (let i = 0; i < currServ.contracts.length; ++i) {
|
|
allPos.push(currServ.contracts[i].fn);
|
|
}
|
|
return allPos;
|
|
}
|
|
|
|
if (input.startsWith("cat ")) {
|
|
for (var i = 0; i < currServ.messages.length; ++i) {
|
|
if (currServ.messages[i] instanceof Message) {
|
|
allPos.push(currServ.messages[i].filename);
|
|
} else {
|
|
allPos.push(currServ.messages[i]);
|
|
}
|
|
}
|
|
for (var i = 0; i < currServ.textFiles.length; ++i) {
|
|
allPos.push(currServ.textFiles[i].fn);
|
|
}
|
|
return allPos;
|
|
}
|
|
|
|
if (input.startsWith("download ")) {
|
|
for (var i = 0; i < currServ.textFiles.length; ++i) {
|
|
allPos.push(currServ.textFiles[i].fn);
|
|
}
|
|
for (var i = 0; i < currServ.scripts.length; ++i) {
|
|
allPos.push(currServ.scripts[i].filename);
|
|
}
|
|
}
|
|
return allPos;
|
|
}
|
|
|
|
let Terminal = {
|
|
//Flags to determine whether the player is currently running a hack or an analyze
|
|
hackFlag: false,
|
|
analyzeFlag: false,
|
|
actionStarted: false,
|
|
actionTime: 0,
|
|
|
|
commandHistory: [],
|
|
commandHistoryIndex: 0,
|
|
|
|
contractOpen: false, //True if a Coding Contract prompt is opened
|
|
|
|
resetTerminalInput: function() {
|
|
if (FconfSettings.WRAP_INPUT) {
|
|
document.getElementById("terminal-input-td").innerHTML =
|
|
"<div id='terminal-input-header' class='prompt'>[" + Player.getCurrentServer().hostname + " ~]" + "$ </div>" +
|
|
'<textarea type="text" id="terminal-input-text-box" class="terminal-input" tabindex="1"/>';
|
|
|
|
//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 + " ~]" + "$ </div>" +
|
|
'<input type="text" id="terminal-input-text-box" class="terminal-input" tabindex="1"/>';
|
|
}
|
|
var hdr = document.getElementById("terminal-input-header");
|
|
hdr.style.display = "inline";
|
|
},
|
|
|
|
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 end = terminalInput.selectionEnd;
|
|
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;
|
|
var end = terminalInput.selectionEnd;
|
|
|
|
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()) / 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.analyzeFlag) {
|
|
Terminal.finishAnalyze(cancelled);
|
|
}
|
|
},
|
|
|
|
//Complete the hack/analyze command
|
|
finishHack: function(cancelled = false) {
|
|
if (cancelled == false) {
|
|
var server = Player.getCurrentServer();
|
|
|
|
//Calculate whether hack was successful
|
|
var hackChance = calculateHackingChance(server);
|
|
var rand = Math.random();
|
|
var expGainedOnSuccess = calculateHackingExpGain(server);
|
|
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);
|
|
return;
|
|
}
|
|
server.manuallyHacked = true;
|
|
var moneyGained = calculatePercentMoneyHacked(server);
|
|
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);
|
|
|
|
post("Hack successful! Gained " + numeralWrapper.format(moneyGained, '($0,0.00)') + " and " + numeralWrapper.format(expGainedOnSuccess, '0.0000') + " 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.format(expGainedOnFailure, '0.0000') + " hacking EXP");
|
|
}
|
|
}
|
|
|
|
//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);
|
|
|
|
Terminal.hackFlag = false;
|
|
},
|
|
|
|
finishAnalyze: function(cancelled = false) {
|
|
if (cancelled == false) {
|
|
let currServ = Player.getCurrentServer();
|
|
post(currServ.hostname + ": ");
|
|
post("Organization name: " + currServ.organizationName);
|
|
var rootAccess = "";
|
|
if (currServ.hasAdminRights) {rootAccess = "YES";}
|
|
else {rootAccess = "NO";}
|
|
post("Root Access: " + rootAccess);
|
|
post("Required hacking skill: " + currServ.requiredHackingSkill);
|
|
post("Server security level: " + numeralWrapper.format(currServ.hackDifficulty, '0.000a'));
|
|
post("Chance to hack: " + numeralWrapper.format(calculateHackingChance(currServ), '0.00%'));
|
|
post("Time to hack: " + numeralWrapper.format(calculateHackingTime(currServ), '0.000') + " seconds");
|
|
post("Total money available on server: " + numeralWrapper.format(currServ.moneyAvailable, '$0,0.00'));
|
|
post("Required number of open ports for NUKE: " + currServ.numOpenPortsRequired);
|
|
|
|
if (currServ.sshPortOpen) {
|
|
post("SSH port: Open")
|
|
} else {
|
|
post("SSH port: Closed")
|
|
}
|
|
|
|
if (currServ.ftpPortOpen) {
|
|
post("FTP port: Open")
|
|
} else {
|
|
post("FTP port: Closed")
|
|
}
|
|
|
|
if (currServ.smtpPortOpen) {
|
|
post("SMTP port: Open")
|
|
} else {
|
|
post("SMTP port: Closed")
|
|
}
|
|
|
|
if (currServ.httpPortOpen) {
|
|
post("HTTP port: Open")
|
|
} else {
|
|
post("HTTP port: Closed")
|
|
}
|
|
|
|
if (currServ.sqlPortOpen) {
|
|
post("SQL port: Open")
|
|
} else {
|
|
post("SQL port: Closed")
|
|
}
|
|
}
|
|
Terminal.analyzeFlag = false;
|
|
|
|
// 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);
|
|
},
|
|
|
|
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.split(";");
|
|
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) {
|
|
//Process any aliases
|
|
command = substituteAliases(command);
|
|
|
|
//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 foodnstuffServ = GetServerByHostname("foodnstuff");
|
|
if (foodnstuffServ == null) {throw new Error("Could not get foodnstuff 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] == "foodnstuff" || commandArray[1] == foodnstuffServ.ip)) {
|
|
Player.getCurrentServer().isConnectedTo = false;
|
|
Player.currentServer = foodnstuffServ.ip;
|
|
Player.getCurrentServer().isConnectedTo = true;
|
|
post("Connected to foodnstuff");
|
|
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") {
|
|
foodnstuffServ.hasAdminRights = true;
|
|
post("NUKE successful! Gained root access to foodnstuff");
|
|
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] == "foodnstuff.script") {
|
|
Engine.loadScriptEditorContent("foodnstuff.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] == "foodnstuff.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] == "foodnstuff.script") {
|
|
//Check that the script exists on this machine
|
|
var runningScript = findRunningScript("foodnstuff.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[1]}`);
|
|
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 "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":
|
|
if (commandArray.length !== 2) {
|
|
postError("Incorrect usage of cat command. Usage: cat [file]");
|
|
return;
|
|
}
|
|
let filename = 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;
|
|
}
|
|
for (var 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;
|
|
}
|
|
}
|
|
for (var i = 0; i < s.textFiles.length; ++i) {
|
|
if (s.textFiles[i].fn === filename) {
|
|
s.textFiles[i].show();
|
|
return;
|
|
}
|
|
}
|
|
postError(`No such file ${filename}`);
|
|
break;
|
|
case "check":
|
|
if (commandArray.length < 2) {
|
|
postError("Incorrect number of arguments. Usage: check [script] [arg1] [arg2]...");
|
|
} else {
|
|
var scriptName = 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();
|
|
}
|
|
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 (var 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":
|
|
if (commandArray.length !== 2) {
|
|
postError("Incorrect usage of download command. Usage: download [script/text file]");
|
|
return;
|
|
}
|
|
var 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
|
|
for (var i = 0; i < s.scripts.length; ++i) {
|
|
if (s.scripts[i].filename === fn) {
|
|
return s.scripts[i].download();
|
|
}
|
|
}
|
|
} else if (fn.endsWith(".txt")) {
|
|
//Download a single text file
|
|
var txtFile = getTextFile(fn, s);
|
|
if (txtFile !== null) {
|
|
return txtFile.download();
|
|
}
|
|
}
|
|
postError(`${fn} does not exist`);
|
|
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 (Player.getCurrentServer().purchasedByPlayer) {
|
|
postError("Cannot hack your own machines! You are currently connected to your home PC or one of your purchased servers");
|
|
} else if (Player.getCurrentServer().hasAdminRights == false ) {
|
|
postError("You do not have admin rights for this machine! Cannot hack");
|
|
} else if (Player.getCurrentServer().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 {
|
|
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.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 (var i = s.runningScripts.length-1; i >= 0; --i) {
|
|
killWorkerScript(s.runningScripts[i], s.ip);
|
|
}
|
|
post("Killing all running scripts. May take up to a few minutes for the scripts to die...");
|
|
break;
|
|
case "ls":
|
|
Terminal.executeListCommand(commandArray);
|
|
break;
|
|
case "lscpu":
|
|
post(Player.getCurrentServer().cpuCores + " Core(s)");
|
|
break;
|
|
case "mem":
|
|
Terminal.executeMemCommand(commandArray);
|
|
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 = 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 = commandArray[1];
|
|
|
|
if (delTarget.endsWith(".exe")) {
|
|
for (let i = 0; i < s.programs.length; ++i) {
|
|
if (s.programs[i] === delTarget) {
|
|
s.programs.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
} else if (isScriptFilename(delTarget)) {
|
|
for (let i = 0; i < s.scripts.length; ++i) {
|
|
if (s.scripts[i].filename === delTarget) {
|
|
//Check that the script isnt currently running
|
|
for (let j = 0; j < s.runningScripts.length; ++j) {
|
|
if (s.runningScripts[j].filename == delTarget) {
|
|
postError("Cannot delete a script that is currently running!");
|
|
return;
|
|
}
|
|
}
|
|
s.scripts.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
} else if (delTarget.endsWith(".lit")) {
|
|
for (let i = 0; i < s.messages.length; ++i) {
|
|
let f = s.messages[i];
|
|
if (!(f instanceof Message) && isString(f) && f === delTarget) {
|
|
s.messages.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
} else if (delTarget.endsWith(".txt")) {
|
|
for (let i = 0; i < s.textFiles.length; ++i) {
|
|
if (s.textFiles[i].fn === delTarget) {
|
|
s.textFiles.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
} else if (delTarget.endsWith(".cct")) {
|
|
for (let i = 0; i < s.contracts.length; ++i) {
|
|
if (s.contracts[i].fn === delTarget) {
|
|
s.contracts.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
postError("Error: No such file exists");
|
|
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":
|
|
if (commandArray.length < 2) {
|
|
postError("Incorrect number of arguments. Usage: tail [script] [arg1] [arg2]...");
|
|
} else {
|
|
let scriptName = commandArray[1];
|
|
if (!isScriptFilename(scriptName)) {
|
|
postError("tail can only be called on .script files (filename must end with .script)");
|
|
return;
|
|
}
|
|
|
|
// Get script arguments
|
|
let args = [];
|
|
for (var i = 2; i < commandArray.length; ++i) {
|
|
args.push(commandArray[i]);
|
|
}
|
|
|
|
//Check that the script exists on this machine
|
|
let runningScript = findRunningScript(scriptName, args, s);
|
|
if (runningScript == null) {
|
|
postError("No such script exists");
|
|
return;
|
|
}
|
|
logBoxCreate(runningScript);
|
|
}
|
|
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;
|
|
}
|
|
|
|
post("Script Threads RAM Usage");
|
|
|
|
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
|
|
let numSpacesScript = 32 - script.filename.length; //26 -> width of name column
|
|
if (numSpacesScript < 0) {numSpacesScript = 0;}
|
|
let spacesScript = Array(numSpacesScript+1).join(" ");
|
|
|
|
//Calculate thread padding
|
|
let numSpacesThread = 16 - (script.threads + "").length; //16 -> width of thread column
|
|
let spacesThread = Array(numSpacesThread+1).join(" ");
|
|
|
|
//Calculate and transform RAM usage
|
|
let ramUsage = numeralWrapper.format(script.getRamUsage() * script.threads, '0.00') + " GB";
|
|
|
|
var entry = [script.filename, spacesScript, script.threads, spacesThread, ramUsage];
|
|
post(entry.join(""));
|
|
}
|
|
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;
|
|
/* eslint-disable no-case-declarations */
|
|
case "wget":
|
|
if (commandArray.length !== 3) {
|
|
postError("Incorrect usage of wget command. Usage: wget [url] [target file]");
|
|
return;
|
|
}
|
|
|
|
let url = commandArray[1];
|
|
let target = comanndArray[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;
|
|
/* eslint-enable no-case-declarations */
|
|
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);
|
|
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;
|
|
}
|
|
post("Total: " + numeralWrapper.format(Player.getCurrentServer().maxRam, '0.00') + " GB");
|
|
post("Used: " + numeralWrapper.format(Player.getCurrentServer().ramUsed, '0.00') + " GB");
|
|
post("Available: " + numeralWrapper.format(Player.getCurrentServer().maxRam - Player.getCurrentServer().ramUsed, '0.00') + " GB");
|
|
},
|
|
|
|
executeKillCommand: function(commandArray) {
|
|
if (commandArray.length < 2) {
|
|
postError("Incorrect usage of kill command. Usage: kill [scriptname] [arg1] [arg2]...");
|
|
return;
|
|
}
|
|
|
|
const s = Player.getCurrentServer();
|
|
const scriptName = commandArray[1];
|
|
const args = [];
|
|
for (let i = 2; i < commandArray.length; ++i) {
|
|
args.push(commandArray[i]);
|
|
}
|
|
const runningScript = findRunningScript(scriptName, args, s);
|
|
if (runningScript == null) {
|
|
postError("No such script is running. Nothing to kill");
|
|
return;
|
|
}
|
|
killWorkerScript(runningScript, s.ip);
|
|
post(`Killing ${scriptName}. May take up to a few seconds for the scripts to die...`);
|
|
},
|
|
|
|
executeListCommand: function(commandArray) {
|
|
if (commandArray.length !== 1 && commandArray.length !== 4) {
|
|
postError("Incorrect usage of ls command. Usage: ls [| grep pattern]");
|
|
return;
|
|
}
|
|
|
|
// grep
|
|
var filter = null;
|
|
if (commandArray.length === 4) {
|
|
if (commandArray[1] === "|" && commandArray[2] === "grep") {
|
|
if (commandArray[3] !== " ") {
|
|
filter = commandArray[3];
|
|
}
|
|
} else {
|
|
postError("Incorrect usage of ls command. Usage: ls [| grep pattern]");
|
|
return;
|
|
}
|
|
}
|
|
|
|
//Display all programs and scripts
|
|
var allFiles = [];
|
|
|
|
//Get all of the programs and scripts on the machine into one temporary array
|
|
const s = Player.getCurrentServer();
|
|
for (const program of s.programs) {
|
|
if (filter) {
|
|
if (program.includes(filter)) {
|
|
allFiles.push(program);
|
|
}
|
|
} else {
|
|
allFiles.push(program);
|
|
}
|
|
}
|
|
for (const script of s.scripts) {
|
|
if (filter) {
|
|
if (script.filename.includes(filter)) {
|
|
allFiles.push(script.filename);
|
|
}
|
|
} else {
|
|
allFiles.push(script.filename);
|
|
}
|
|
|
|
}
|
|
for (const msgOrLit of s.messages) {
|
|
if (filter) {
|
|
if (msgOrLit instanceof Message) {
|
|
if (msgOrLit.filename.includes(filter)) {
|
|
allFiles.push(msgOrLit.filename);
|
|
}
|
|
} else if (msgOrLit.includes(filter)) {
|
|
allFiles.push(msgOrLit);
|
|
}
|
|
} else {
|
|
if (msgOrLit instanceof Message) {
|
|
allFiles.push(msgOrLit.filename);
|
|
} else {
|
|
allFiles.push(msgOrLit);
|
|
}
|
|
}
|
|
}
|
|
for (const txt of s.textFiles) {
|
|
if (filter) {
|
|
if (txt.fn.includes(filter)) {
|
|
allFiles.push(txt.fn);
|
|
}
|
|
} else {
|
|
allFiles.push(txt.fn);
|
|
}
|
|
}
|
|
for (const contract of s.contracts) {
|
|
if (filter) {
|
|
if (contract.fn.includes(filter)) {
|
|
allFiles.push(contract.fn);
|
|
}
|
|
} else {
|
|
allFiles.push(contract.fn);
|
|
}
|
|
}
|
|
|
|
//Sort the files alphabetically then print each
|
|
allFiles.sort();
|
|
|
|
for (var i = 0; i < allFiles.length; i++) {
|
|
post(allFiles[i]);
|
|
}
|
|
},
|
|
|
|
executeMemCommand: function(commandArray) {
|
|
if (commandArray.length !== 2 && commandArray.length !== 4) {
|
|
postError("Incorrect usage of mem command. usage: mem [scriptname] [-t] [number threads]");
|
|
return;
|
|
}
|
|
|
|
const s = Player.getCurrentServer();
|
|
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;
|
|
}
|
|
}
|
|
|
|
for (let i = 0; i < s.scripts.length; ++i) {
|
|
if (scriptName === s.scripts[i].filename) {
|
|
const scriptBaseRamUsage = s.scripts[i].ramUsage;
|
|
const ramUsage = scriptBaseRamUsage * numThreads;
|
|
|
|
post(`This script requires ${numeralWrapper.format(ramUsage, '0.00')} GB of RAM to run for ${numThreads} thread(s)`);
|
|
return;
|
|
}
|
|
}
|
|
postError("No such script exists!");
|
|
},
|
|
|
|
executeNanoCommand: function(commandArray) {
|
|
if (commandArray.length !== 2) {
|
|
postError("Incorrect usage of nano command. Usage: nano [scriptname]");
|
|
return;
|
|
}
|
|
|
|
const s = Player.getCurrentServer();
|
|
const filename = commandArray[1];
|
|
if (filename === ".fconf") {
|
|
let text = createFconf();
|
|
Engine.loadScriptEditorContent(filename, text);
|
|
return;
|
|
} else if (isScriptFilename(filename)) {
|
|
for (let i = 0; i < s.scripts.length; i++) {
|
|
if (filename == s.scripts[i].filename) {
|
|
Engine.loadScriptEditorContent(filename, s.scripts[i].code);
|
|
return;
|
|
}
|
|
}
|
|
} else if (filename.endsWith(".txt")) {
|
|
for (let i = 0; i < s.textFiles.length; ++i) {
|
|
if (filename === s.textFiles[i].fn) {
|
|
Engine.loadScriptEditorContent(filename, s.textFiles[i].text);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
postError("Invalid file. Only scripts (.script, .ns, .js), text files (.txt), or .fconf can be edited with nano"); return;
|
|
}
|
|
Engine.loadScriptEditorContent(filename); // Open a new file
|
|
},
|
|
|
|
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();
|
|
post("Hostname IP Root Access");
|
|
for (let i = 0; i < currServ.serversOnNetwork.length; i++) {
|
|
//Add hostname
|
|
let entry = getServerOnNetwork(currServ, i);
|
|
if (entry == null) { continue; }
|
|
entry = entry.hostname;
|
|
|
|
//Calculate padding and add IP
|
|
let numSpaces = 21 - entry.length;
|
|
let spaces = Array(numSpaces+1).join(" ");
|
|
entry += spaces;
|
|
entry += getServerOnNetwork(currServ, i).ip;
|
|
|
|
//Calculate padding and add root access info
|
|
let hasRoot;
|
|
if (getServerOnNetwork(currServ, i).hasAdminRights) {
|
|
hasRoot = 'Y';
|
|
} else {
|
|
hasRoot = 'N';
|
|
}
|
|
numSpaces = 21 - getServerOnNetwork(currServ, i).ip.length;
|
|
spaces = Array(numSpaces+1).join(" ");
|
|
entry += spaces;
|
|
entry += 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;
|
|
}
|
|
|
|
var stack = [];
|
|
var depthQueue = [0];
|
|
var currServ = Player.getCurrentServer();
|
|
stack.push(currServ);
|
|
while(stack.length != 0) {
|
|
var s = stack.pop();
|
|
var d = depthQueue.pop();
|
|
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 {
|
|
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 dashes = Array(d * 2 + 1).join("-");
|
|
var c = "NO";
|
|
if (s.hasAdminRights) {c = "YES";}
|
|
post(dashes + "Root Access: " + c + ", Required hacking skill: " + s.requiredHackingSkill);
|
|
post(dashes + "Number of open ports required to NUKE: " + s.numOpenPortsRequired);
|
|
post(dashes + "RAM: " + 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) {return;}
|
|
Terminal.connectToServer(hostname);
|
|
}
|
|
}());//Immediate invocation
|
|
}
|
|
},
|
|
|
|
executeScpCommand(commandArray) {
|
|
if (commandArray.length !== 3) {
|
|
postError("Incorrect usage of scp command. Usage: scp [file] [destination hostname/ip]");
|
|
return;
|
|
}
|
|
const scriptname = 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 ip = destServer.ip;
|
|
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}`);
|
|
},
|
|
|
|
//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;
|
|
}
|
|
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: " + numeralWrapper.format(calculateHackingTime(targetServer), '0.0') + "s");
|
|
post("Netscript grow() execution time: " + numeralWrapper.format(calculateGrowTime(targetServer), '0.0') + "s");
|
|
post("Netscript weaken() execution time: " + numeralWrapper.format(calculateWeakenTime(targetServer), '0.0') + "s");
|
|
};
|
|
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 fulfilled = Player.augmentations.length >= 30 &&
|
|
Player.money.gt(1e11) &&
|
|
((Player.hacking_skill >= 2500)||
|
|
(Player.strength >= 1500 &&
|
|
Player.defense >= 1500 &&
|
|
Player.dexterity >= 1500 &&
|
|
Player.agility >= 1500));
|
|
if(!fulfilled) {
|
|
post("Augmentations: " + Player.augmentations.length + " / 30");
|
|
|
|
post("Money: " + numeralWrapper.format(Player.money.toNumber(), '($0.000a)') + " / " + numeralWrapper.format(1e11, '($0.000a)'));
|
|
post("One path below must be fulfilled...");
|
|
post("----------HACKING PATH----------");
|
|
post("Hacking skill: " + Player.hacking_skill + " / 2500");
|
|
post("----------COMBAT PATH----------");
|
|
post("Strength: " + Player.strength + " / 1500");
|
|
post("Defense: " + Player.defense + " / 1500");
|
|
post("Dexterity: " + Player.dexterity + " / 1500");
|
|
post("Agility: " + Player.agility + " / 1500");
|
|
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);
|
|
},
|
|
|
|
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();
|
|
|
|
let numThreads = 1;
|
|
const args = [];
|
|
const scriptName = commandArray[1];
|
|
|
|
if (commandArray.length > 2) {
|
|
if (commandArray.length >= 4 && commandArray[2] == "-t") {
|
|
numThreads = Math.round(parseFloat(commandArray[3]));
|
|
if (isNaN(numThreads) || numThreads < 1) {
|
|
postError("Invalid number of threads specified. Number of threads must be greater than 0");
|
|
return;
|
|
}
|
|
for (let i = 4; i < commandArray.length; ++i) {
|
|
args.push(commandArray[i]);
|
|
}
|
|
} else {
|
|
for (let i = 2; i < commandArray.length; ++i) {
|
|
args.push(commandArray[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//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 (var i = 0; i < server.scripts.length; i++) {
|
|
if (server.scripts[i].filename == scriptName) {
|
|
//Check for admin rights and that there is enough RAM availble to run
|
|
var script = server.scripts[i];
|
|
var ramUsage = script.ramUsage * numThreads;
|
|
var ramAvailable = server.maxRam - server.ramUsed;
|
|
|
|
if (server.hasAdminRights == false) {
|
|
post("Need root access to run script");
|
|
return;
|
|
} else 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;
|
|
} else {
|
|
//Able to run script
|
|
post("Running script with " + numThreads + " thread(s) and args: " + arrayToString(args) + ".");
|
|
post("May take a few seconds to start up the process...");
|
|
var runningScriptObj = new RunningScript(script, args);
|
|
runningScriptObj.threads = numThreads;
|
|
server.runningScripts.push(runningScriptObj);
|
|
|
|
addWorkerScript(runningScriptObj, server);
|
|
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};
|