Misc

ArchiSteamFarm/Bot.cs

@@ -43,10 +43,6 @@ namespace ArchiSteamFarm {
 
 		private static readonly uint LoginID = MsgClientLogon.ObfuscationMask; // This must be the same for all ASF bots and all ASF processes
 
-		private readonly string SentryFile;
-		private readonly Timer AcceptConfirmationsTimer;
-		private readonly Timer SendItemsTimer;
-
 		internal readonly string BotName;
 		internal readonly ArchiHandler ArchiHandler;
 		internal readonly ArchiWebHandler ArchiWebHandler;
@@ -54,6 +50,9 @@ namespace ArchiSteamFarm {
 		internal readonly BotDatabase BotDatabase;
 		internal readonly SteamClient SteamClient;
 
+		private readonly string SentryFile;
+		private readonly Timer AcceptConfirmationsTimer;
+		private readonly Timer SendItemsTimer;
 		private readonly CallbackManager CallbackManager;
 		private readonly CardsFarmer CardsFarmer;
 		private readonly SteamApps SteamApps;
@@ -63,8 +62,7 @@ namespace ArchiSteamFarm {
 
 		internal bool KeepRunning { get; private set; } = false;
 
-		private bool InvalidPassword = false;
+		private bool InvalidPassword, LoggedInElsewhere;
-		private bool LoggedInElsewhere = false;
 		private string AuthCode, TwoFactorAuth;
 
 		internal static async Task RefreshCMs(uint cellID) {
@@ -87,6 +85,14 @@ namespace ArchiSteamFarm {
 			}
 		}
 
+		private static bool IsOwner(ulong steamID) {
+			if (steamID == 0) {
+				return false;
+			}
+
+			return steamID == Program.GlobalConfig.SteamOwnerID;
+		}
+
 		private static bool IsValidCdKey(string key) {
 			if (string.IsNullOrEmpty(key)) {
 				return false;
@@ -171,10 +177,12 @@ namespace ArchiSteamFarm {
 			BotDatabase = BotDatabase.Load(botPath + ".db");
 			SentryFile = botPath + ".bin";
 
-			// Support and convert SDA files
+			if (BotDatabase.SteamGuardAccount == null) {
-			string maFilePath = botPath + ".maFile";
+				// Support and convert SDA files
-			if (BotDatabase.SteamGuardAccount == null && File.Exists(maFilePath)) {
+				string maFilePath = botPath + ".maFile";
-				ImportAuthenticator(maFilePath);
+				if (File.Exists(maFilePath)) {
+					ImportAuthenticator(maFilePath);
+				}
 			}
 
 			// Initialize
@@ -232,7 +240,7 @@ namespace ArchiSteamFarm {
 
 			if (BotConfig.SendTradePeriod > 0 && SendItemsTimer == null) {
 				SendItemsTimer = new Timer(
-					async e => await ResponseSendTrade().ConfigureAwait(false),
+					async e => await ResponseSendTrade(BotConfig.SteamMasterID).ConfigureAwait(false),
 					null,
 					TimeSpan.FromHours(BotConfig.SendTradePeriod), // Delay
 					TimeSpan.FromHours(BotConfig.SendTradePeriod) // Period
@@ -244,7 +252,15 @@ namespace ArchiSteamFarm {
 			}
 
 			// Start
-			Start().Wait();
+			Task.Run(async () => await Start().ConfigureAwait(false)).Forget();
+		}
+
+		internal bool IsMaster(ulong steamID) {
+			if (steamID == 0) {
+				return false;
+			}
+
+			return steamID == BotConfig.SteamMasterID || IsOwner(steamID);
 		}
 
 		internal async Task AcceptConfirmations(Confirmation.ConfirmationType allowedConfirmationType = Confirmation.ConfirmationType.Unknown) {
@@ -294,99 +310,97 @@ namespace ArchiSteamFarm {
 
 		internal async Task OnFarmingFinished(bool farmedSomething) {
 			if (farmedSomething && BotConfig.SendOnFarmingFinished) {
-				await ResponseSendTrade().ConfigureAwait(false);
+				await ResponseSendTrade(BotConfig.SteamMasterID).ConfigureAwait(false);
 			}
+
 			if (BotConfig.ShutdownOnFarmingFinished) {
 				await Shutdown().ConfigureAwait(false);
 			}
 		}
 
-		internal async Task<string> HandleMessage(string message) {
+		internal async Task<string> Response(ulong steamID, string message) {
-			if (string.IsNullOrEmpty(message)) {
+			if (steamID == 0 || string.IsNullOrEmpty(message)) {
 				return null;
 			}
 
 			if (!message.StartsWith("!")) {
-				return await ResponseRedeem(BotName, message, true).ConfigureAwait(false);
+				return await ResponseRedeem(steamID, BotName, message, true).ConfigureAwait(false);
 			}
 
 			if (!message.Contains(" ")) {
 				switch (message) {
 					case "!2fa":
-						return Response2FA();
+						return Response2FA(steamID);
 					case "!2faoff":
-						return Response2FAOff();
+						return Response2FAOff(steamID);
 					case "!2faok":
-						return await Response2FAOK().ConfigureAwait(false);
+						return await Response2FAOK(steamID).ConfigureAwait(false);
 					case "!exit":
-						Program.Exit();
+						return ResponseExit(steamID);
-						return null;
 					case "!farm":
-						return await ResponseFarm().ConfigureAwait(false);
+						return await ResponseFarm(steamID).ConfigureAwait(false);
 					case "!loot":
-						return await ResponseSendTrade().ConfigureAwait(false);
+						return await ResponseSendTrade(steamID).ConfigureAwait(false);
 					case "!rejoinchat":
-						return ResponseRejoinChat();
+						return ResponseRejoinChat(steamID);
 					case "!restart":
-						Program.Restart();
+						return ResponseRestart(steamID);
-						return null;
 					case "!status":
-						return ResponseStatus();
+						return ResponseStatus(steamID);
 					case "!statusall":
-						return ResponseStatusAll();
+						return ResponseStatusAll(steamID);
 					case "!stop":
-						return await ResponseStop().ConfigureAwait(false);
+						return await ResponseStop(steamID).ConfigureAwait(false);
 					case "!update":
-						await Program.CheckForUpdate().ConfigureAwait(false);
+						return await ResponseUpdate(steamID).ConfigureAwait(false);
-						return "Done!";
 					default:
-						return "Unrecognized command: " + message;
+						return ResponseUnknown(steamID);
 				}
 			} else {
 				string[] args = message.Split(' ');
 				switch (args[0]) {
 					case "!2fa":
-						return Response2FA(args[1]);
+						return Response2FA(steamID, args[1]);
 					case "!2faoff":
-						return Response2FAOff(args[1]);
+						return Response2FAOff(steamID, args[1]);
 					case "!2faok":
-						return await Response2FAOK(args[1]).ConfigureAwait(false);
+						return await Response2FAOK(steamID, args[1]).ConfigureAwait(false);
 					case "!addlicense":
 						if (args.Length > 2) {
-							return await ResponseAddLicense(args[1], args[2]).ConfigureAwait(false);
+							return await ResponseAddLicense(steamID, args[1], args[2]).ConfigureAwait(false);
 						} else {
-							return await ResponseAddLicense(BotName, args[1]).ConfigureAwait(false);
+							return await ResponseAddLicense(steamID, BotName, args[1]).ConfigureAwait(false);
 						}
 					case "!farm":
-						return await ResponseFarm(args[1]).ConfigureAwait(false);
+						return await ResponseFarm(steamID, args[1]).ConfigureAwait(false);
 					case "!loot":
-						return await ResponseSendTrade(args[1]).ConfigureAwait(false);
+						return await ResponseSendTrade(steamID, args[1]).ConfigureAwait(false);
 					case "!owns":
 						if (args.Length > 2) {
-							return await ResponseOwns(args[1], args[2]).ConfigureAwait(false);
+							return await ResponseOwns(steamID, args[1], args[2]).ConfigureAwait(false);
 						} else {
-							return await ResponseOwns(BotName, args[1]).ConfigureAwait(false);
+							return await ResponseOwns(steamID, BotName, args[1]).ConfigureAwait(false);
 						}
 					case "!play":
 						if (args.Length > 2) {
-							return await ResponsePlay(args[1], args[2]).ConfigureAwait(false);
+							return await ResponsePlay(steamID, args[1], args[2]).ConfigureAwait(false);
 						} else {
-							return await ResponsePlay(BotName, args[1]).ConfigureAwait(false);
+							return await ResponsePlay(steamID, BotName, args[1]).ConfigureAwait(false);
 						}
 					case "!redeem":
 						if (args.Length > 2) {
-							return await ResponseRedeem(args[1], args[2], false).ConfigureAwait(false);
+							return await ResponseRedeem(steamID, args[1], args[2], false).ConfigureAwait(false);
 						} else {
-							return await ResponseRedeem(BotName, args[1], false).ConfigureAwait(false);
+							return await ResponseRedeem(steamID, BotName, args[1], false).ConfigureAwait(false);
 						}
 					case "!start":
-						return await ResponseStart(args[1]).ConfigureAwait(false);
+						return await ResponseStart(steamID, args[1]).ConfigureAwait(false);
 					case "!status":
-						return ResponseStatus(args[1]);
+						return ResponseStatus(steamID, args[1]);
 					case "!stop":
-						return await ResponseStop(args[1]).ConfigureAwait(false);
+						return await ResponseStop(steamID, args[1]).ConfigureAwait(false);
 					default:
-						return "Unrecognized command: " + args[0];
+						return ResponseUnknown(steamID);
 				}
 			}
 		}
@@ -492,7 +506,15 @@ namespace ArchiSteamFarm {
 			Logging.LogGenericInfo("Successfully finished importing mobile authenticator!", BotName);
 		}
 
-		private string ResponseStatus() {
+		private string ResponseStatus(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
 			if (CardsFarmer.CurrentGamesFarming.Count > 0) {
 				return "Bot " + BotName + " is currently farming appIDs: " + string.Join(", ", CardsFarmer.CurrentGamesFarming) + " and has a total of " + CardsFarmer.GamesToFarm.Count + " games left to farm.";
 			} else {
@@ -500,8 +522,8 @@ namespace ArchiSteamFarm {
 			}
 		}
 
-		private static string ResponseStatus(string botName) {
+		private static string ResponseStatus(ulong steamID, string botName) {
-			if (string.IsNullOrEmpty(botName)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName)) {
 				return null;
 			}
 
@@ -510,17 +532,25 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return bot.ResponseStatus();
+			return bot.ResponseStatus(steamID);
 		}
 
-		private static string ResponseStatusAll() {
+		private static string ResponseStatusAll(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsOwner(steamID)) {
+				return null;
+			}
+
 			StringBuilder result = new StringBuilder(Environment.NewLine);
 
 			int totalBotsCount = Bots.Count;
 			int runningBotsCount = 0;
 
 			foreach (Bot bot in Bots.Values) {
-				result.Append(bot.ResponseStatus() + Environment.NewLine);
+				result.Append(bot.ResponseStatus(steamID) + Environment.NewLine);
 				if (bot.KeepRunning) {
 					runningBotsCount++;
 				}
@@ -530,7 +560,15 @@ namespace ArchiSteamFarm {
 			return result.ToString();
 		}
 
-		private async Task<string> ResponseSendTrade() {
+		private async Task<string> ResponseSendTrade(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
 			if (BotConfig.SteamMasterID == 0) {
 				return "Trade couldn't be send because SteamMasterID is not defined!";
 			}
@@ -550,8 +588,8 @@ namespace ArchiSteamFarm {
 			}
 		}
 
-		private static async Task<string> ResponseSendTrade(string botName) {
+		private static async Task<string> ResponseSendTrade(ulong steamID, string botName) {
-			if (string.IsNullOrEmpty(botName)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName)) {
 				return null;
 			}
 
@@ -560,10 +598,18 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return await bot.ResponseSendTrade().ConfigureAwait(false);
+			return await bot.ResponseSendTrade(steamID).ConfigureAwait(false);
 		}
 
-		private string Response2FA() {
+		private string Response2FA(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
 			if (BotDatabase.SteamGuardAccount == null) {
 				return "That bot doesn't have ASF 2FA enabled!";
 			}
@@ -572,8 +618,8 @@ namespace ArchiSteamFarm {
 			return "2FA Token: " + BotDatabase.SteamGuardAccount.GenerateSteamGuardCode() + " (expires in " + timeLeft + " seconds)";
 		}
 
-		private static string Response2FA(string botName) {
+		private static string Response2FA(ulong steamID, string botName) {
-			if (string.IsNullOrEmpty(botName)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName)) {
 				return null;
 			}
 
@@ -582,10 +628,18 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return bot.Response2FA();
+			return bot.Response2FA(steamID);
 		}
 
-		private string Response2FAOff() {
+		private string Response2FAOff(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
 			if (BotDatabase.SteamGuardAccount == null) {
 				return "That bot doesn't have ASF 2FA enabled!";
 			}
@@ -597,8 +651,8 @@ namespace ArchiSteamFarm {
 			}
 		}
 
-		private static string Response2FAOff(string botName) {
+		private static string Response2FAOff(ulong steamID, string botName) {
-			if (string.IsNullOrEmpty(botName)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName)) {
 				return null;
 			}
 
@@ -607,10 +661,18 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return bot.Response2FAOff();
+			return bot.Response2FAOff(steamID);
 		}
 
-		private async Task<string> Response2FAOK() {
+		private async Task<string> Response2FAOK(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
 			if (BotDatabase.SteamGuardAccount == null) {
 				return "That bot doesn't have ASF 2FA enabled!";
 			}
@@ -619,8 +681,8 @@ namespace ArchiSteamFarm {
 			return "Done!";
 		}
 
-		private static async Task<string> Response2FAOK(string botName) {
+		private static async Task<string> Response2FAOK(ulong steamID, string botName) {
-			if (string.IsNullOrEmpty(botName)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName)) {
 				return null;
 			}
 
@@ -629,16 +691,37 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return await bot.Response2FAOK().ConfigureAwait(false);
+			return await bot.Response2FAOK(steamID).ConfigureAwait(false);
 		}
 
-		private async Task<string> ResponseFarm() {
+		private static string ResponseExit(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsOwner(steamID)) {
+				return null;
+			}
+
+			Program.Exit();
+			return null;
+		}
+
+		private async Task<string> ResponseFarm(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
 			await CardsFarmer.RestartFarming().ConfigureAwait(false);
 			return "Done!";
 		}
 
-		private static async Task<string> ResponseFarm(string botName) {
+		private static async Task<string> ResponseFarm(ulong steamID, string botName) {
-			if (string.IsNullOrEmpty(botName)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName)) {
 				return null;
 			}
 
@@ -647,11 +730,15 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return await bot.ResponseFarm().ConfigureAwait(false);
+			return await bot.ResponseFarm(steamID).ConfigureAwait(false);
 		}
 
-		private async Task<string> ResponseRedeem(string message, bool validate) {
+		private async Task<string> ResponseRedeem(ulong steamID, string message, bool validate) {
-			if (string.IsNullOrEmpty(message)) {
+			if (steamID == 0 || string.IsNullOrEmpty(message)) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
 				return null;
 			}
 
@@ -791,8 +878,8 @@ namespace ArchiSteamFarm {
 			return response.ToString();
 		}
 
-		private static async Task<string> ResponseRedeem(string botName, string message, bool validate) {
+		private static async Task<string> ResponseRedeem(ulong steamID, string botName, string message, bool validate) {
-			if (string.IsNullOrEmpty(botName) || string.IsNullOrEmpty(message)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName) || string.IsNullOrEmpty(message)) {
 				return null;
 			}
 
@@ -801,10 +888,18 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return await bot.ResponseRedeem(message, validate).ConfigureAwait(false);
+			return await bot.ResponseRedeem(steamID, message, validate).ConfigureAwait(false);
 		}
 
-		private static string ResponseRejoinChat() {
+		private static string ResponseRejoinChat(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsOwner(steamID)) {
+				return null;
+			}
+
 			foreach (Bot bot in Bots.Values) {
 				bot.JoinMasterChat();
 			}
@@ -812,8 +907,25 @@ namespace ArchiSteamFarm {
 			return "Done!";
 		}
 
-		private async Task<string> ResponseAddLicense(HashSet<uint> gameIDs) {
+		private static string ResponseRestart(ulong steamID) {
-			if (gameIDs == null || gameIDs.Count == 0) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsOwner(steamID)) {
+				return null;
+			}
+
+			Program.Restart();
+			return null;
+		}
+
+		private async Task<string> ResponseAddLicense(ulong steamID, HashSet<uint> gameIDs) {
+			if (steamID == 0 || gameIDs == null || gameIDs.Count == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
 				return null;
 			}
 
@@ -833,8 +945,8 @@ namespace ArchiSteamFarm {
 			return result.ToString();
 		}
 
-		private static async Task<string> ResponseAddLicense(string botName, string games) {
+		private static async Task<string> ResponseAddLicense(ulong steamID, string botName, string games) {
-			if (string.IsNullOrEmpty(botName) || string.IsNullOrEmpty(games)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName) || string.IsNullOrEmpty(games)) {
 				return null;
 			}
 
@@ -858,11 +970,15 @@ namespace ArchiSteamFarm {
 				return "Couldn't parse any games given!";
 			}
 
-			return await bot.ResponseAddLicense(gamesToRedeem).ConfigureAwait(false);
+			return await bot.ResponseAddLicense(steamID, gamesToRedeem).ConfigureAwait(false);
 		}
 
-		private async Task<string> ResponseOwns(string games) {
+		private async Task<string> ResponseOwns(ulong steamID, string games) {
-			if (string.IsNullOrEmpty(games)) {
+			if (steamID == 0 || string.IsNullOrEmpty(games)) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
 				return null;
 			}
 
@@ -900,8 +1016,8 @@ namespace ArchiSteamFarm {
 			}
 		}
 
-		private static async Task<string> ResponseOwns(string botName, string games) {
+		private static async Task<string> ResponseOwns(ulong steamID, string botName, string games) {
-			if (string.IsNullOrEmpty(botName) || string.IsNullOrEmpty(games)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName) || string.IsNullOrEmpty(games)) {
 				return null;
 			}
 
@@ -910,11 +1026,15 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return await bot.ResponseOwns(games).ConfigureAwait(false);
+			return await bot.ResponseOwns(steamID, games).ConfigureAwait(false);
 		}
 
-		private async Task<string> ResponsePlay(HashSet<uint> gameIDs) {
+		private async Task<string> ResponsePlay(ulong steamID, HashSet<uint> gameIDs) {
-			if (gameIDs == null || gameIDs.Count == 0) {
+			if (steamID == 0 || gameIDs == null || gameIDs.Count == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
 				return null;
 			}
 
@@ -930,8 +1050,8 @@ namespace ArchiSteamFarm {
 			return "Done!";
 		}
 
-		private static async Task<string> ResponsePlay(string botName, string games) {
+		private static async Task<string> ResponsePlay(ulong steamID, string botName, string games) {
-			if (string.IsNullOrEmpty(botName) || string.IsNullOrEmpty(games)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName) || string.IsNullOrEmpty(games)) {
 				return null;
 			}
 
@@ -955,10 +1075,18 @@ namespace ArchiSteamFarm {
 				return "Couldn't parse any games given!";
 			}
 
-			return await bot.ResponsePlay(gamesToPlay).ConfigureAwait(false);
+			return await bot.ResponsePlay(steamID, gamesToPlay).ConfigureAwait(false);
 		}
 
-		private async Task<string> ResponseStart() {
+		private async Task<string> ResponseStart(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
 			if (KeepRunning) {
 				return "That bot instance is already running!";
 			}
@@ -967,8 +1095,8 @@ namespace ArchiSteamFarm {
 			return "Done!";
 		}
 
-		private static async Task<string> ResponseStart(string botName) {
+		private static async Task<string> ResponseStart(ulong steamID, string botName) {
-			if (string.IsNullOrEmpty(botName)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName)) {
 				return null;
 			}
 
@@ -977,10 +1105,18 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return await bot.ResponseStart().ConfigureAwait(false);
+			return await bot.ResponseStart(steamID).ConfigureAwait(false);
 		}
 
-		private async Task<string> ResponseStop() {
+		private async Task<string> ResponseStop(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
 			if (!KeepRunning) {
 				return "That bot instance is already inactive!";
 			}
@@ -989,8 +1125,8 @@ namespace ArchiSteamFarm {
 			return "Done!";
 		}
 
-		private static async Task<string> ResponseStop(string botName) {
+		private static async Task<string> ResponseStop(ulong steamID, string botName) {
-			if (string.IsNullOrEmpty(botName)) {
+			if (steamID == 0 || string.IsNullOrEmpty(botName)) {
 				return null;
 			}
 
@@ -999,7 +1135,32 @@ namespace ArchiSteamFarm {
 				return "Couldn't find any bot named " + botName + "!";
 			}
 
-			return await bot.ResponseStop().ConfigureAwait(false);
+			return await bot.ResponseStop(steamID).ConfigureAwait(false);
+		}
+
+		private string ResponseUnknown(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsMaster(steamID)) {
+				return null;
+			}
+
+			return "ERROR: Unknown command!";
+		}
+
+		private static async Task<string> ResponseUpdate(ulong steamID) {
+			if (steamID == 0) {
+				return null;
+			}
+
+			if (!IsOwner(steamID)) {
+				return null;
+			}
+
+			await Program.CheckForUpdate().ConfigureAwait(false);
+			return "Done!";
 		}
 
 		private void HandleCallbacks() {
@@ -1009,12 +1170,12 @@ namespace ArchiSteamFarm {
 			}
 		}
 
-		private async Task HandleMessage(ulong steamID, string message) {
+		private async Task HandleMessage(ulong chatID, ulong steamID, string message) {
-			if (steamID == 0 || string.IsNullOrEmpty(message)) {
+			if (chatID == 0 || steamID == 0 || string.IsNullOrEmpty(message)) {
 				return;
 			}
 
-			SendMessage(steamID, await HandleMessage(message).ConfigureAwait(false));
+			SendMessage(chatID, await Response(steamID, message).ConfigureAwait(false));
 		}
 
 		private void SendMessage(ulong steamID, string message) {
@@ -1223,7 +1384,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.PatronID != BotConfig.SteamMasterID) {
+			if (!IsMaster(callback.PatronID)) {
 				return;
 			}
 
@@ -1239,7 +1400,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.ChatterID != BotConfig.SteamMasterID) {
+			if (!IsMaster(callback.ChatterID)) {
 				return;
 			}
 
@@ -1248,7 +1409,7 @@ namespace ArchiSteamFarm {
 					SteamFriends.LeaveChat(callback.ChatRoomID);
 					break;
 				default:
-					await HandleMessage(callback.ChatRoomID, callback.Message).ConfigureAwait(false);
+					await HandleMessage(callback.ChatRoomID, callback.ChatterID, callback.Message).ConfigureAwait(false);
 					break;
 			}
 		}
@@ -1268,9 +1429,10 @@ namespace ArchiSteamFarm {
 						// TODO: Accept clan invites from master?
 						break;
 					default:
-						if (friend.SteamID == BotConfig.SteamMasterID) {
+						if (!IsMaster(friend.SteamID)) {
-							SteamFriends.AddFriend(friend.SteamID);
+							break;
 						}
+						SteamFriends.AddFriend(friend.SteamID);
 						break;
 				}
 			}
@@ -1285,11 +1447,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.Sender != BotConfig.SteamMasterID) {
+			await HandleMessage(callback.Sender, callback.Sender, callback.Message).ConfigureAwait(false);
-				return;
-			}
-
-			await HandleMessage(callback.Sender, callback.Message).ConfigureAwait(false);
 		}
 
 		private async void OnFriendMsgHistory(SteamFriends.FriendMsgHistoryCallback callback) {
@@ -1301,7 +1459,7 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.SteamID != BotConfig.SteamMasterID) {
+			if (!IsMaster(callback.SteamID)) {
 				return;
 			}
 
@@ -1323,7 +1481,7 @@ namespace ArchiSteamFarm {
 			}
 
 			// Handle the message
-			await HandleMessage(callback.SteamID, lastMessage.Message).ConfigureAwait(false);
+			await HandleMessage(callback.SteamID, callback.SteamID, lastMessage.Message).ConfigureAwait(false);
 		}
 
 		private void OnAccountInfo(SteamUser.AccountInfoCallback callback) {
@@ -1379,19 +1537,18 @@ namespace ArchiSteamFarm {
 						Program.GlobalDatabase.CellID = callback.CellID;
 					}
 
-					// Support and convert SDA files
+					if (BotDatabase.SteamGuardAccount == null) {
-					string maFilePath = Path.Combine(Program.ConfigDirectory, callback.ClientSteamID.ConvertToUInt64() + ".maFile");
+						// Support and convert SDA files
-					if (BotDatabase.SteamGuardAccount == null && File.Exists(maFilePath)) {
+						string maFilePath = Path.Combine(Program.ConfigDirectory, callback.ClientSteamID.ConvertToUInt64() + ".maFile");
-						ImportAuthenticator(maFilePath);
+						if (File.Exists(maFilePath)) {
-					}
+							ImportAuthenticator(maFilePath);
-
+						} else if (TwoFactorAuth == null && BotConfig.UseAsfAsMobileAuthenticator) {
-					if (BotConfig.UseAsfAsMobileAuthenticator && TwoFactorAuth == null && BotDatabase.SteamGuardAccount == null) {
+							LinkMobileAuthenticator();
-						LinkMobileAuthenticator();
+						}
 					}
 
 					// Reset one-time-only access tokens
-					AuthCode = null;
+					AuthCode = TwoFactorAuth = null;
-					TwoFactorAuth = null;
 
 					ResetGamesPlayed();
 
@@ -1405,20 +1562,24 @@ namespace ArchiSteamFarm {
 					}
 
 					if (BotConfig.DismissInventoryNotifications) {
-						await ArchiWebHandler.MarkInventory().ConfigureAwait(false);
+						Task.Run(async () => await ArchiWebHandler.MarkInventory().ConfigureAwait(false)).Forget();
 					}
 
 					if (BotConfig.SteamMasterClanID != 0) {
-						await ArchiWebHandler.JoinClan(BotConfig.SteamMasterClanID).ConfigureAwait(false);
+						Task.Run(async () => {
-						JoinMasterChat();
+							await ArchiWebHandler.JoinClan(BotConfig.SteamMasterClanID).ConfigureAwait(false);
+							JoinMasterChat();
+						}).Forget();
 					}
 
 					if (Program.GlobalConfig.Statistics) {
-						await ArchiWebHandler.JoinClan(ArchiSCFarmGroup).ConfigureAwait(false);
+						Task.Run(async () => {
-						SteamFriends.JoinChat(ArchiSCFarmGroup);
+							await ArchiWebHandler.JoinClan(ArchiSCFarmGroup).ConfigureAwait(false);
+							SteamFriends.JoinChat(ArchiSCFarmGroup);
+						}).Forget();
 					}
 
-					Trading.CheckTrades();
+					Task.Run(() => Trading.CheckTrades()).Forget();
 
 					Task.Run(async () => await CardsFarmer.StartFarming().ConfigureAwait(false)).Forget();
 					break;

ArchiSteamFarm/BotDatabase.cs

@@ -57,10 +57,10 @@ namespace ArchiSteamFarm {
 			}
 		}
 
-		[JsonProperty(Required = Required.AllowNull)]
+		[JsonProperty]
 		private string _LoginKey;
 
-		[JsonProperty(Required = Required.AllowNull)]
+		[JsonProperty]
 		private SteamGuardAccount _SteamGuardAccount;
 
 		private string FilePath;

ArchiSteamFarm/GlobalConfig.cs

@@ -47,6 +47,9 @@ namespace ArchiSteamFarm {
 		[JsonProperty(Required = Required.DisallowNull)]
 		internal EUpdateChannel UpdateChannel { get; private set; } = EUpdateChannel.Stable;
 
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal ulong SteamOwnerID { get; private set; } = 0;
+
 		[JsonProperty(Required = Required.DisallowNull)]
 		internal byte MaxFarmingTime { get; private set; } = 10;
 
@@ -77,6 +80,9 @@ namespace ArchiSteamFarm {
 		[JsonProperty(Required = Required.DisallowNull)]
 		internal ushort WCFPort { get; private set; } = 1242;
 
+		[JsonProperty(Required = Required.DisallowNull)]
+		internal bool LogToFile { get; private set; } = true;
+
 		[JsonProperty(Required = Required.DisallowNull)]
 		internal bool Statistics { get; private set; } = true;
 

ArchiSteamFarm/Logging.cs

@@ -31,18 +31,18 @@ namespace ArchiSteamFarm {
 	internal static class Logging {
 		private static readonly object FileLock = new object();
 
-		internal static bool? LogToFile { get; set; } = null;
+		private static bool LogToFile = false;
 
 		internal static void Init() {
-			if (!LogToFile.HasValue) {
+			LogToFile = Program.GlobalConfig.LogToFile;
-				LogToFile = true;
-			}
 
-			lock (FileLock) {
+			if (LogToFile) {
-				try {
+				lock (FileLock) {
-					File.Delete(Program.LogFile);
+					try {
-				} catch (Exception e) {
+						File.Delete(Program.LogFile);
-					LogGenericException(e);
+					} catch (Exception e) {
+						LogGenericException(e);
+					}
 				}
 			}
 		}
@@ -123,7 +123,7 @@ namespace ArchiSteamFarm {
 				} catch { }
 			}
 
-			if (LogToFile.GetValueOrDefault()) {
+			if (LogToFile) {
 				lock (FileLock) {
 					try {
 						File.AppendAllText(Program.LogFile, loggedMessage);

ArchiSteamFarm/Program.cs

@@ -371,13 +371,6 @@ namespace ArchiSteamFarm {
 				switch (arg) {
 					case "--client":
 						Mode = EMode.Client;
-						Logging.LogToFile = false;
-						break;
-					case "--log":
-						Logging.LogToFile = true;
-						break;
-					case "--no-log":
-						Logging.LogToFile = false;
 						break;
 					case "--server":
 						Mode = EMode.Server;
@@ -451,11 +444,11 @@ namespace ArchiSteamFarm {
 
 			// If debugging is on, we prepare debug directory prior to running
 			if (GlobalConfig.Debug) {
-				if (Directory.Exists(Program.DebugDirectory)) {
+				if (Directory.Exists(DebugDirectory)) {
-					Directory.Delete(Program.DebugDirectory, true);
+					Directory.Delete(DebugDirectory, true);
 					Thread.Sleep(1000); // Dirty workaround giving Windows some time to sync
 				}
-				Directory.CreateDirectory(Program.DebugDirectory);
+				Directory.CreateDirectory(DebugDirectory);
 
 				SteamKit2.DebugLog.AddListener(new Debugging.DebugListener(Path.Combine(Program.DebugDirectory, "debug.txt")));
 				SteamKit2.DebugLog.Enabled = true;

ArchiSteamFarm/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2.0.1.1")]
+[assembly: AssemblyVersion("2.0.1.3")]
-[assembly: AssemblyFileVersion("2.0.1.1")]
+[assembly: AssemblyFileVersion("2.0.1.3")]

ArchiSteamFarm/WCF.cs

@@ -116,7 +116,7 @@ namespace ArchiSteamFarm {
 			Logging.LogGenericInfo("Received command: " + input);
 
 			string command = '!' + input;
-			string output = bot.HandleMessage(command).Result; // TODO: This should be asynchronous
+			string output = bot.Response(Program.GlobalConfig.SteamOwnerID, command).Result; // TODO: This should be asynchronous
 
 			Logging.LogGenericInfo("Answered to command: " + input + " with: " + output);
 			return output;

ArchiSteamFarm/config/ASF.json

@@ -2,6 +2,7 @@
   "Debug": false,
   "AutoUpdates": true,
   "UpdateChannel": 1,
+  "SteamOwnerID": 0,
   "MaxFarmingTime": 10,
   "IdleFarmingPeriod": 3,
   "FarmingDelay": 5,
@@ -12,6 +13,7 @@
   "HttpTimeout": 60,
   "WCFHostname": "localhost",
   "WCFPort": 1242,
+  "LogToFile": true,
   "Statistics": true,
   "HackIgnoreMachineID": false,
   "Blacklist": [