multiSSH3 5.80__py3-none-any.whl → 6.2__py3-none-any.whl

multiSSH3.py

@@ -6,6 +6,33 @@
 #     "ipaddress",
 # ]
 # ///
+import argparse
+import functools
+import getpass
+import glob
+import io
+import ipaddress
+import itertools
+import json
+import math
+import os
+import queue
+import re
+import shutil
+import signal
+import socket
+import string
+import subprocess
+import sys
+import tempfile
+import textwrap
+import threading
+import time
+import typing
+import uuid
+from collections import Counter, deque, defaultdict
+from itertools import count, product
+
 __curses_available = False
 __resource_lib_available = False
 try:
@@ -20,45 +47,47 @@ try:
 except ImportError:
 	pass
 
-import subprocess
-import threading
-import time
-import os
-import argparse
-from itertools import product
-import re
-import string
-import ipaddress
-import sys
-import json
-import socket
-import io
-import signal
-import functools
-import glob
-import shutil
-import getpass
-import uuid
-import tempfile
-import math
-from itertools import count
-import queue
-
 try:
 	# Check if functiools.cache is available
-	cache_decorator = functools.cache
-except AttributeError:
-	try:
-		# Check if functools.lru_cache is available
-		cache_decorator = functools.lru_cache(maxsize=None)
-	except AttributeError:
-		# If neither is available, use a dummy decorator
-		def cache_decorator(func):
-			return func
-version = '5.80'
+	# cache_decorator = functools.cache
+	def cache_decorator(user_function):
+		def _make_hashable(item):
+			if isinstance(item, typing.Mapping):
+				# Sort items so that {'a':1, 'b':2} and {'b':2, 'a':1} hash the same
+				return tuple(
+					( _make_hashable(k), _make_hashable(v) )
+					for k, v in sorted(item.items(), key=lambda item: item[0])
+				)
+			if isinstance(item, (list, set, tuple)):
+				return tuple(_make_hashable(e) for e in item)
+			# Fallback: assume item is already hashable
+			return item
+		def decorating_function(user_function):
+			# Create the real cached function
+			cached_func = functools.lru_cache(maxsize=None)(user_function)
+			@functools.wraps(user_function)
+			def wrapper(*args, **kwargs):
+				# Convert all args/kwargs to hashable equivalents
+				hashable_args = tuple(_make_hashable(a) for a in args)
+				hashable_kwargs = {
+					k: _make_hashable(v) for k, v in kwargs.items()
+				}
+				# Call the lru-cached version
+				return cached_func(*hashable_args, **hashable_kwargs)
+			# Expose cache statistics and clear method
+			wrapper.cache_info = cached_func.cache_info
+			wrapper.cache_clear = cached_func.cache_clear
+			return wrapper
+		return decorating_function(user_function)
+except Exception:
+	# If lrucache is not available, use a dummy decorator
+	print('Warning: functools.lru_cache is not available, multiSSH3 will run slower without cache.',file=sys.stderr)
+	def cache_decorator(func):
+		return func
+version = '6.02'
 VERSION = version
 __version__ = version
-COMMIT_DATE = '2025-07-09'
+COMMIT_DATE = '2025-11-10'
 
 CONFIG_FILE_CHAIN = ['./multiSSH3.config.json',
 					 '~/multiSSH3.config.json',
@@ -67,16 +96,22 @@ CONFIG_FILE_CHAIN = ['./multiSSH3.config.json',
 					 '/etc/multiSSH3.d/multiSSH3.config.json',
 					 '/etc/multiSSH3.config.json'] # The first one has the highest priority
 
+ERRORS = []
 
 # TODO: Add terminal TUI
 
 #%% ------------ Pre Helper Functions ----------------
 def eprint(*args, **kwargs):
+	global ERRORS
 	try:
-		print(*args, file=sys.stderr, **kwargs)
+		if 'file' in kwargs:
+			print(*args, **kwargs)
+		else:
+			print(*args, file=sys.stderr, **kwargs)
 	except Exception as e:
 		print(f"Error: Cannot print to stderr: {e}")
 		print(*args, **kwargs)
+	ERRORS.append(' '.join(map(str,args)))
 
 def _exit_with_code(code, message=None):
 	'''
@@ -118,33 +153,6 @@ def signal_handler(sig, frame):
 		os.system(f'pkill -ef {os.path.basename(__file__)}')
 		_exit_with_code(1, 'Exiting immediately due to Ctrl C')
 
-# def input_with_timeout_and_countdown(timeout, prompt='Please enter your selection'):
-# 	"""
-# 	Read an input from the user with a timeout and a countdown.
-
-# 	Parameters:
-# 	timeout (int): The timeout value in seconds.
-# 	prompt (str): The prompt message to display to the user. Default is 'Please enter your selection'.
-
-# 	Returns:
-# 	str or None: The user input if received within the timeout, or None if no input is received.
-# 	"""
-# 	import select
-# 	# Print the initial prompt with the countdown
-# 	eprint(f"{prompt} [{timeout}s]: ", end='', flush=True)
-# 	# Loop until the timeout
-# 	for remaining in range(timeout, 0, -1):
-# 		# If there is an input, return it
-# 		# this only works on linux
-# 		if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
-# 			return input().strip()
-# 		# Print the remaining time
-# 		eprint(f"\r{prompt} [{remaining}s]: ", end='', flush=True)
-# 		# Wait a second
-# 		time.sleep(1)
-# 	# If there is no input, return None
-# 	return None
-
 def input_with_timeout_and_countdown(timeout, prompt='Please enter your selection'):
 	"""
 	Read input from the user with a timeout (cross-platform).
@@ -221,7 +229,7 @@ def getIP(hostname: str,local=False):
 	# Then we check the DNS
 	try:
 		return socket.gethostbyname(hostname)
-	except:
+	except Exception:
 		return None
 
 
@@ -264,6 +272,7 @@ class Host:
 		self.output_buffer = io.BytesIO()
 		self.stdout_buffer = io.BytesIO()
 		self.stderr_buffer = io.BytesIO()
+		self.thread = None
 
 	def __iter__(self):
 		return zip(['name', 'command', 'returncode', 'stdout', 'stderr'], [self.name, self.command, self.returncode, self.stdout, self.stderr])
@@ -276,6 +285,13 @@ extraargs={self.extraargs}, resolvedName={self.resolvedName}, i={self.i}, uuid={
 identity_file={self.identity_file}, ip={self.ip}, current_color_pair={self.current_color_pair}"
 	def __str__(self):
 		return f"Host(name={self.name}, command={self.command}, returncode={self.returncode}, stdout={self.stdout}, stderr={self.stderr})"
+	def get_output_hash(self):
+		return hash((
+			self.command,
+			tuple(self.stdout),
+			tuple(self.stderr),
+			self.returncode
+		))
 
 #%% ------------ Load Defaults ( Config ) File ----------------
 def load_config_file(config_file):
@@ -293,8 +309,8 @@ def load_config_file(config_file):
 	try:
 		with open(config_file,'r') as f:
 			config = json.load(f)
-	except:
-		eprint(f"Error: Cannot load config file {config_file!r}")
+	except Exception as e:
+		eprint(f"Error: Cannot load config file {config_file!r}: {e}")
 		return {}
 	return config
 
@@ -305,7 +321,7 @@ DEFAULT_HOSTS = 'all'
 DEFAULT_USERNAME = None
 DEFAULT_PASSWORD = ''
 DEFAULT_IDENTITY_FILE = None
-DEDAULT_SSH_KEY_SEARCH_PATH = '~/.ssh/'
+DEFAULT_SSH_KEY_SEARCH_PATH = '~/.ssh/'
 DEFAULT_USE_KEY = False
 DEFAULT_EXTRA_ARGS = None
 DEFAULT_ONE_ON_ONE = False
@@ -319,15 +335,26 @@ DEFAULT_INTERVAL = 0
 DEFAULT_IPMI = False
 DEFAULT_IPMI_INTERFACE_IP_PREFIX = ''
 DEFAULT_INTERFACE_IP_PREFIX = None
+DEFAULT_IPMI_USERNAME = 'ADMIN'
+DEFAULT_IPMI_PASSWORD = ''
 DEFAULT_NO_WATCH = False
-DEFAULT_CURSES_MINIMUM_CHAR_LEN = 40
-DEFAULT_CURSES_MINIMUM_LINE_LEN = 1
+DEFAULT_WINDOW_WIDTH = 40
+DEFAULT_WINDOW_HEIGHT = 1
 DEFAULT_SINGLE_WINDOW = False
 DEFAULT_ERROR_ONLY = False
 DEFAULT_NO_OUTPUT = False
 DEFAULT_RETURN_ZERO = False
 DEFAULT_NO_ENV = False
-DEFAULT_ENV_FILE = '/etc/profile.d/hosts.sh'
+DEFAULT_ENV_FILE = ''
+DEFAULT_ENV_FILES = ['/etc/profile.d/hosts.sh',
+					 '~/.bashrc',
+					 '~/.zshrc',
+					 '~/host.env',
+					 '~/hosts.env',
+					 '.env',
+					 'host.env',
+					 'hosts.env',
+					 ]
 DEFAULT_NO_HISTORY = False
 DEFAULT_HISTORY_FILE = '~/.mssh_history'
 DEFAULT_MAX_CONNECTIONS = 4 * os.cpu_count()
@@ -337,7 +364,9 @@ DEFAULT_GREPPABLE_MODE = False
 DEFAULT_SKIP_UNREACHABLE = True
 DEFAULT_SKIP_HOSTS = ''
 DEFAULT_ENCODING = 'utf-8'
+DEFAULT_DIFF_DISPLAY_THRESHOLD = 0.6
 SSH_STRICT_HOST_KEY_CHECKING = False
+FORCE_TRUECOLOR = False
 ERROR_MESSAGES_TO_IGNORE = [
 	'Pseudo-terminal will not be allocated because stdin is not a terminal',
 	'Connection to .* closed',
@@ -347,6 +376,24 @@ ERROR_MESSAGES_TO_IGNORE = [
 	'Killed by signal',
 	'Connection reset by peer',
 ]
+__DEFAULT_COLOR_PALETTE = {
+	'cyan': (86, 173, 188),
+	'green': (114, 180, 43),
+	'magenta': (140, 107, 200),
+	'red': (196, 38, 94),
+	'white': (227, 227, 221),
+	'yellow': (179, 180, 43),
+	'blue': (106, 126, 200),
+	'bright_black': (102, 102, 102),
+	'bright_blue': (129, 154, 255),
+	'bright_cyan': (102, 217, 239),
+	'bright_green': (126, 226, 46),
+	'bright_magenta': (174, 129, 255),
+	'bright_red': (249, 38, 114),
+	'bright_white': (248, 248, 242),
+	'bright_yellow': (226, 226, 46),
+}
+COLOR_PALETTE = __DEFAULT_COLOR_PALETTE.copy()
 _DEFAULT_CALLED = True
 _DEFAULT_RETURN_UNFINISHED = False
 _DEFAULT_UPDATE_UNREACHABLE_HOSTS = True
@@ -366,6 +413,9 @@ if __ERROR_MESSAGES_TO_IGNORE_REGEX:
 	__ERROR_MESSAGES_TO_IGNORE_REGEX = re.compile(__ERROR_MESSAGES_TO_IGNORE_REGEX)
 else:
 	__ERROR_MESSAGES_TO_IGNORE_REGEX =  re.compile('|'.join(ERROR_MESSAGES_TO_IGNORE))
+if DEFAULT_ENV_FILE:
+	if DEFAULT_ENV_FILE not in DEFAULT_ENV_FILES:
+		DEFAULT_ENV_FILES.append(DEFAULT_ENV_FILE)
 
 #%% Load mssh Functional Global Variables
 __global_suppress_printout = False
@@ -373,7 +423,7 @@ __mainReturnCode = 0
 __failedHosts = set()
 __wildCharacters = ['*','?','x']
 _no_env = DEFAULT_NO_ENV
-_env_file = DEFAULT_ENV_FILE
+_env_files = DEFAULT_ENV_FILES
 __globalUnavailableHosts = dict()
 __ipmiiInterfaceIPPrefix = DEFAULT_IPMI_INTERFACE_IP_PREFIX
 __keyPressesIn = [[]]
@@ -386,6 +436,12 @@ __max_connections_nofile_limit_supported = 0
 __thread_start_delay = 0
 _encoding = DEFAULT_ENCODING
 __returnZero = DEFAULT_RETURN_ZERO
+__running_threads = set()
+__control_master_string = '''Host *
+  ControlMaster auto
+  ControlPath /run/user/%i/ssh_sockets_%C
+  ControlPersist 3600
+'''
 if __resource_lib_available:
 	# Get the current limits
 	_, __system_nofile_limit = resource.getrlimit(resource.RLIMIT_NOFILE)
@@ -433,12 +489,12 @@ def check_path(program_name):
 
 [check_path(program) for program in _binCalled]
 
-def find_ssh_key_file(searchPath = DEDAULT_SSH_KEY_SEARCH_PATH):
+def find_ssh_key_file(searchPath = DEFAULT_SSH_KEY_SEARCH_PATH):
 	'''
 	Find the ssh public key file
 
 	Args:
-		searchPath (str, optional): The path to search. Defaults to DEDAULT_SSH_KEY_SEARCH_PATH.
+		searchPath (str, optional): The path to search. Defaults to DEFAULT_SSH_KEY_SEARCH_PATH.
 
 	Returns:
 		str: The path to the ssh key file
@@ -454,35 +510,65 @@ def find_ssh_key_file(searchPath = DEDAULT_SSH_KEY_SEARCH_PATH):
 	return None
 
 @cache_decorator
-def readEnvFromFile(environemnt_file = ''):
+def readEnvFromFile():
 	'''
 	Read the environment variables from env_file
 	Returns:
 		dict: A dictionary of environment variables
 	'''
-	global env
-	try:
-		if env:
-			return env
-	except:
-		env = {}
-	global _env_file
-	if environemnt_file:
-		envf = environemnt_file
-	else:
-		envf = _env_file if _env_file else DEFAULT_ENV_FILE
-	if os.path.exists(envf):
-		with open(envf,'r') as f:
-			for line in f:
-				if line.startswith('#') or not line.strip():
+	global _env_files
+	global _no_env
+	envfs = _env_files if _env_files else DEFAULT_ENV_FILES
+	translator = str.maketrans('&|"', ';;\'')
+	replacement_re = re.compile(r'\$(?:[A-Za-z_]\w*|\{[A-Za-z_]\w*\})')
+	environemnt = {}
+	scrubCounter = 0
+	for envf in envfs:
+		envf = os.path.expanduser(os.path.expandvars(envf))
+		if os.path.exists(envf):
+			with open(envf,'r') as f:
+				lines = f.readlines()
+			for line in lines:
+				line = line.strip()
+				if not line or line.startswith('#') or '=' not in line:
 					continue
-				key, value = line.replace('export ', '', 1).strip().split('=', 1)
-				key = key.strip().strip('"').strip("'")
-				value = value.strip().strip('"').strip("'")
-				# avoid infinite recursion
-				if key != value:
-					env[key] = value.strip('"').strip("'")
-	return env
+				line = line.translate(translator)
+				commands = re.split(r";(?=(?:[^']*'[^']*')*[^']*$)", line)
+				for command in commands:
+					if not command or command.startswith('#') or '=' not in command or command.startswith('alias '):
+						continue
+					fields = re.split(r" (?=(?:[^']*'[^']*')*[^']*$)", command)
+					for field in fields:
+						try:
+							if field.startswith('export '):
+								field = field.replace('export ', '', 1).strip()
+							if not field or field.startswith('#') or '=' not in field:
+								continue
+							key, _, values = field.partition('=')
+							key = key.strip().strip("'")
+							values = values.strip().strip("'")
+							if '$' in values:
+								scrubCounter += 16
+							if key and values and key != values:
+								environemnt[key] = values
+						except Exception:
+							continue
+	while scrubCounter:
+		scrubCounter -= 1
+		found = False
+		for key, value in environemnt.items():
+			if '$' in value:
+				for match in replacement_re.findall(value):
+					ref_key = match.strip('${}')
+					ref_value = environemnt.get(ref_key) if ref_key != key else None
+					if not ref_value and not _no_env:
+						ref_value = os.environ.get(ref_key)
+					if ref_value:
+						environemnt[key] = value.replace(match, ref_value)
+						found = True
+		if not found:
+			break
+	return environemnt
 
 def replace_magic_strings(string,keys,value,case_sensitive=False):
 	'''
@@ -580,6 +666,428 @@ def pretty_format_table(data, delimiter = '\t',header = None):
 				outTable.append(row_format.format(*row))
 	return '\n'.join(outTable) + '\n'
 
+def join_threads(threads=__running_threads,timeout=None):
+	'''
+	Join threads
+
+	@params:
+		threads: The threads to join
+		timeout: The timeout
+
+	@returns:
+		None
+	'''
+	global __running_threads
+	for thread in threads:
+		thread.join(timeout=timeout)
+	if threads is __running_threads:
+		__running_threads = {t for t in threads if t.is_alive()}
+
+def format_commands(commands):
+	if not commands:
+		commands = []
+	else:
+		commands = [commands] if isinstance(commands,str) else commands
+		# reformat commands into a list of strings, join the iterables if they are not strings
+		try:
+			commands = [' '.join(command) if not isinstance(command,str) else command for command in commands]
+		except Exception as e:
+			eprint(f"Warning: commands should ideally be a list of strings. Now mssh had failed to convert {commands!r} to a list of strings. Continuing anyway but expect failures. Error: {e}")
+	return commands
+
+class OrderedMultiSet(deque):
+	"""
+	A deque extension with O(1) average lookup time.
+	Maintains all deque functionality while tracking item counts.
+	"""
+	def __init__(self, iterable=None, maxlen=None):
+		"""Initialize with optional iterable and maxlen."""
+		super().__init__(maxlen=maxlen)
+		self._counter = Counter()
+		if iterable is not None:
+			self.extend(iterable)
+	def append(self, item):
+		"""Add item to the right end. O(1)."""
+		if len(self) == self.maxlen:
+			self._counter -= Counter([self[0]])
+			# self._counter[self[0]] -= 1
+			# self._counter += Counter()
+		super().append(item) 
+		self._counter[item] += 1
+	def appendleft(self, item):
+		"""Add item to the left end. O(1)."""
+		if len(self) == self.maxlen:
+			self._counter -= Counter([self[-1]])
+		super().appendleft(item)
+		self._counter[item] += 1
+	def pop(self):
+		"""Remove and return item from right end. O(1)."""
+		try:
+			item = super().pop()
+			self._counter -= Counter([item])
+			return item
+		except IndexError:
+			return None
+	def popleft(self):
+		"""Remove and return item from left end. O(1)."""
+		try:
+			item = super().popleft()
+			self._counter -= Counter([item])
+			return item
+		except IndexError:
+			return None
+	def put(self, item):
+		"""Alias for append, but return removed item - add to right end (FIFO put)."""
+		removed = None
+		if len(self) == self.maxlen:
+			removed = self[0]  # Item that will be removed
+			self._counter -= Counter([removed])
+		super().append(item) 
+		self._counter[item] += 1
+		return removed
+	def put_left(self, item):
+		"""Alias for appendleft, but return removed item - add to left end (LIFO put)."""
+		removed = None
+		if len(self) == self.maxlen:
+			removed = self[-1]  # Item that will be removed
+			self._counter -= Counter([removed])
+		super().appendleft(item)
+		self._counter[item] += 1
+		return removed
+	def get(self):
+		"""Alias for popleft - remove from left end (FIFO get)."""
+		return self.popleft()
+	def remove(self, value):
+		"""Remove first occurrence of value. O(n)."""
+		if value not in self._counter:
+			return None
+		super().remove(value)
+		self._counter -= Counter([value])
+	def clear(self):
+		"""Remove all items. O(1)."""
+		super().clear()
+		self._counter.clear()
+	def extend(self, iterable):
+		"""Extend deque by appending elements from iterable. O(k)."""
+		# if maxlen is set, and the new length exceeds maxlen, we clear then efficiently extend
+		try:
+			if not self.maxlen or len(self) + len(iterable) <= self.maxlen:
+				super().extend(iterable)
+				self._counter.update(iterable)
+			elif len(iterable) >= self.maxlen:
+				self.clear()
+				if isinstance(iterable, (list, tuple)):
+					iterable = iterable[-self.maxlen:]
+				else:
+					iterable = itertools.islice(iterable, len(iterable) - self.maxlen, None)
+				super().extend(iterable)
+				self._counter.update(iterable)
+			else:
+				num_to_keep = self.maxlen - len(iterable)
+				self.truncateright(num_to_keep)
+				super().extend(iterable)
+				self._counter.update(iterable)
+		except TypeError:
+			return self.extend(list(iterable))
+	def extendleft(self, iterable):
+		"""Extend left side by appending elements from iterable. O(k)."""
+		# if maxlen is set, and the new length exceeds maxlen, we clear then efficiently extendleft
+		try:
+			if not self.maxlen or len(self) + len(iterable) <= self.maxlen:
+				super().extendleft(iterable)
+				self._counter.update(iterable)
+			elif len(iterable) >= self.maxlen:
+				self.clear()
+				if isinstance(iterable, (list, tuple)):
+					iterable = iterable[:self.maxlen]
+				else:
+					iterable = itertools.islice(iterable, 0, self.maxlen)
+				super().extendleft(iterable)
+				self._counter.update(iterable)
+			else:
+				num_to_keep = self.maxlen - len(iterable)
+				self.truncate(num_to_keep)
+				super().extendleft(iterable)
+				self._counter.update(iterable)
+		except TypeError:
+			return self.extendleft(list(iterable))
+	def update(self, iterable):
+		"""Extend deque by appending elements from iterable. Alias for extend. O(k)."""
+		return self.extend(iterable)
+	def updateleft(self, iterable):
+		"""Extend left side by appending elements from iterable. Alias for extendleft. O(k)."""
+		return self.extendleft(iterable)
+	def truncate(self, n):
+		"""Truncate to keep left n items. O(n)."""
+		kept = list(itertools.islice(self, n))
+		dropped = Counter(itertools.islice(self, n, None))
+		super().clear()
+		super().extend(kept)
+		self._counter -= dropped
+	def truncateright(self, n):
+		"""Truncate to keep right n items. O(n)."""
+		kept = list(itertools.islice(self, len(self) - n, None))
+		dropped = Counter(itertools.islice(self, 0, len(self) - n))
+		super().clear()
+		super().extend(kept)
+		self._counter -= dropped
+	def rotate(self, n=1):
+		"""Rotate deque n steps to the right. O(k) where k = min(n, len)."""
+		super().rotate(n)
+	def __contains__(self, item):
+		"""Check if item exists in deque. O(1) average."""
+		# return item in self._counter
+		return super().__contains__(item)
+	def count(self, item):
+		"""Return number of occurrences of item. O(1)."""
+		return self._counter[item]
+	def __setitem__(self, index, value):
+		"""Set item at index. O(1) for access, O(1) for counter update."""
+		old_value = self[index]
+		super().__setitem__(index, value)
+		self._counter -= Counter([old_value])
+		self._counter[value] += 1
+		return old_value
+	def __delitem__(self, index):
+		"""Delete item at index. O(n) for deletion, O(1) for counter update."""
+		value = self[index]
+		super().__delitem__(index)
+		self._counter -= Counter([value])
+		return value
+	def insert(self, index, value):
+		"""Insert value at index. O(n) for insertion, O(1) for counter update."""
+		super().insert(index, value)
+		self._counter[value] += 1
+	def reverse(self):
+		"""Reverse deque in place. O(n)."""
+		super().reverse()
+	def copy(self):
+		"""Create a shallow copy. O(n)."""
+		new_deque = OrderedMultiSet(maxlen=self.maxlen)
+		new_deque.extend(self)
+		return new_deque
+	def __copy__(self):
+		"""Support for copy.copy()."""
+		return self.copy()
+	def __repr__(self):
+		"""String representation."""
+		if self.maxlen is not None:
+			return f"OrderedMultiSet({list(self)}, maxlen={self.maxlen})"
+		return f"OrderedMultiSet({list(self)})"
+	def peek(self):
+		"""Return leftmost item without removing it."""
+		try:
+			return self[0]
+		except IndexError:
+			return None
+	def peek_right(self):
+		"""Return rightmost item without removing it."""
+		try:
+			return self[-1]
+		except IndexError:
+			return None
+	def __iadd__(self, value):
+		return self.extend(value)
+	def __add__(self, value):
+		new_deque = self.copy()
+		new_deque.extend(value)
+		return new_deque
+	def __mul__(self, value):
+		new_deque = OrderedMultiSet(maxlen=self.maxlen)
+		for _ in range(value):
+			new_deque.extend(self)
+		return new_deque
+	def __imul__(self, value):
+		if value <= 0:
+			self.clear()
+			return self
+		for _ in range(value - 1):
+			self.extend(self)
+		return self
+	def __eq__(self, value):
+		if isinstance(value, OrderedMultiSet):
+			return self._counter == value._counter
+		return super().__eq__(value)
+
+def get_terminal_size():
+	'''
+	Get the terminal size
+
+	@params:
+		None
+
+	@returns:
+		(int,int): the number of columns and rows of the terminal
+	'''
+	try:
+		import os
+		_tsize = os.get_terminal_size()
+	except Exception:
+		try:
+			import fcntl
+			import struct
+			import termios
+			packed = fcntl.ioctl(0, termios.TIOCGWINSZ, struct.pack('HHHH', 0, 0, 0, 0))
+			_tsize = struct.unpack('HHHH', packed)[:2]
+		except Exception:
+			import shutil
+			_tsize = shutil.get_terminal_size(fallback=(120, 30))
+	return _tsize
+
+@cache_decorator
+def get_terminal_color_capability():
+	global FORCE_TRUECOLOR
+	if not sys.stdout.isatty():
+		return 'None'
+	term = os.environ.get("TERM", "")
+	if term == "dumb":
+		return 'None'
+	elif term == "linux":
+		return '8'
+	elif FORCE_TRUECOLOR:
+		return '24bit'
+	colorterm = os.environ.get("COLORTERM", "")
+	if colorterm in ("truecolor", "24bit", "24-bit"):
+		return '24bit'
+	if term in ("xterm-truecolor", "xterm-24bit", "xterm-kitty", "alacritty", "wezterm", "foot", "terminology"):
+		return '24bit'
+	elif "256" in term:
+		return '256'
+	elif "16" in term:
+		return '16'
+	try:
+		curses.setupterm()
+		colors = curses.tigetnum("colors")
+		# tigetnum returns -1 if the capability isn’t defined
+		if colors >= 16777216:
+			return '24bit'
+		elif colors >= 256:
+			return '256'
+		elif colors >= 16:
+			return '16'
+		elif colors > 0:
+			return '8'
+		else:
+			return 'None'
+	except Exception:
+		return 'None'
+
+@cache_decorator
+def rgb_to_ansi_color_string(r, g, b):
+	"""
+	Return an ANSI escape sequence setting the foreground to (r,g,b)
+	approximated to the terminal's capability, or '' if none.
+	"""
+	cap = get_terminal_color_capability()
+	if cap == 'None':
+		return ''
+	if cap == '24bit':
+		return f'\x1b[38;2;{r};{g};{b}m'
+	if cap == '256':
+		idx = _rgb_to_256_color(r, g, b)
+		return f'\x1b[38;5;{idx}m'
+	if cap == '16':
+		idx = _rgb_to_16_color(r, g, b)
+		# 0–7 = 30–37, 8–15 = 90–97
+		if idx < 8:
+			return f'\x1b[{30 + idx}m'
+		else:
+			return f'\x1b[{90 + (idx - 8)}m'
+	if cap == '8':
+		idx = _rgb_to_8_color(r, g, b)
+		return f'\x1b[{30 + idx}m'
+	return ''
+
+def _rgb_to_256_color(r, g, b):
+	"""
+	Map (r,g,b) to the 256-color cube or grayscale ramp.
+	"""
+	# if it’s already gray, use the 232–255 grayscale ramp
+	if r == g == b:
+		# 24 shades from 232 to 255
+		return 232 + int(round(r / 255 * 23))
+	# else map each channel to 0–5
+	def to6(v):
+		return int(round(v / 255 * 5))
+	r6, g6, b6 = to6(r), to6(g), to6(b)
+	return 16 + 36 * r6 + 6 * g6 + b6
+
+def _rgb_to_16_color(r, g, b):
+	"""
+	Pick the nearest of the 16 ANSI standard colors.
+	Returns an index 0-15.
+	"""
+	palette = [
+		(0, 0, 0),       # 0 black
+		(128, 0, 0),     # 1 red
+		(0, 128, 0),     # 2 green
+		(128, 128, 0),   # 3 yellow
+		(0, 0, 128),     # 4 blue
+		(128, 0, 128),   # 5 magenta
+		(0, 128, 128),   # 6 cyan
+		(192, 192, 192), # 7 white (light gray)
+		(128, 128, 128), # 8 bright black (dark gray)
+		(255, 0, 0),     # 9 bright red
+		(0, 255, 0),     # 10 bright green
+		(255, 255, 0),   # 11 bright yellow
+		(0, 0, 255),     # 12 bright blue
+		(255, 0, 255),   # 13 bright magenta
+		(0, 255, 255),   # 14 bright cyan
+		(255, 255, 255), # 15 bright white
+	]
+	best_idx = 0
+	best_dist = float('inf')
+	for i, (pr, pg, pb) in enumerate(palette):
+		dist = (r - pr)**2 + (g - pg)**2 + (b - pb)**2
+		if dist < best_dist:
+			best_dist = dist
+			best_idx = i
+	return best_idx
+
+def _rgb_to_8_color(r, g, b):
+	"""
+	Reduce to 8 colors by mapping to the 16-color index then clamping 0-7.
+	"""
+	return _rgb_to_16_color(r//2, g//2, b//2)
+
+
+def int_to_color(hash_value, min_brightness=100,max_brightness=220):
+	r = (hash_value >> 16) & 0xFF
+	g = (hash_value >> 8) & 0xFF
+	b = hash_value & 0xFF
+	brightness = math.sqrt(0.299 * r**2 + 0.587 * g**2 + 0.114 * b**2)
+	if brightness < min_brightness:
+		return int_to_color(hash(str(hash_value)), min_brightness, max_brightness)
+	if brightness > max_brightness:
+		return int_to_color(hash(str(hash_value)), min_brightness, max_brightness)
+	return (r, g, b)
+
+__previous_color_rgb = ()
+@cache_decorator
+def int_to_unique_ansi_color(number):
+	'''
+	Convert a number to a unique ANSI color code
+
+	Args:
+		number (int): The number to convert
+	Returns:
+		int: The ANSI color code
+	'''
+	global __previous_color_rgb
+	# Use a hash function to generate a consistent integer from the string
+	color_capability = get_terminal_color_capability()
+	if color_capability == 'None':
+		return ''
+	if color_capability == '24bit':
+		r, g, b = int_to_color(number)
+	else:
+		# for 256 colors and below, reduce brightness threshold as we do not have many color to work with
+		r, g, b = int_to_color(number, min_brightness=70, max_brightness=190)
+	if sum(abs(a - b) for a, b in zip((r, g, b), __previous_color_rgb)) <= 256:
+		r, g, b = int_to_color(hash(str(number)))
+	__previous_color_rgb = (r, g, b)
+	return rgb_to_ansi_color_string(r, g, b)
+
 #%% ------------ Compacting Hostnames ----------------
 def __tokenize_hostname(hostname):
 	"""
@@ -924,17 +1432,22 @@ def compact_hostnames(Hostnames,verify = True):
 		['sub-s[1-2]']
 	"""
 	global __global_suppress_printout
-	if not isinstance(Hostnames, frozenset):
-		hostSet = frozenset(Hostnames)
-	else:
-		hostSet = Hostnames
+	# if not isinstance(Hostnames, frozenset):
+	# 	hostSet = frozenset(Hostnames)
+	# else:
+	# 	hostSet = Hostnames
+	hostSet = frozenset(expand_hostnames(
+		hostname.strip()
+		for hostnames_str in Hostnames
+		for hostname in hostnames_str.split(',')
+	))
 	compact_hosts = __compact_hostnames(hostSet)
 	if verify:
-		if set(expand_hostnames(compact_hosts)) != set(expand_hostnames(hostSet)):
+		if frozenset(expand_hostnames(compact_hosts)) != hostSet:
 			if not __global_suppress_printout:
 				eprint(f"Error compacting hostnames: {hostSet} -> {compact_hosts}")
 			compact_hosts = hostSet
-	return compact_hosts
+	return sorted(compact_hosts)
 
 #%% ------------ Expanding Hostnames ----------------
 @cache_decorator
@@ -1159,51 +1672,53 @@ def __handle_reading_stream(stream,target, host,buffer:io.BytesIO):
 		buffer.truncate(0)
 		host.output_buffer.seek(0)
 		host.output_buffer.truncate(0)
-
-	for char in iter(lambda:stream.read(1), b''):
-		host.lastUpdateTime = time.monotonic()
-		if char == b'\n':
-			add_line(buffer,target, host)
-			continue
-		elif char == b'\r':
-			buffer.seek(0)
-			host.output_buffer.seek(0)
-		elif char == b'\x08':
-			# backspace
-			if buffer.tell() > 0:
-				buffer.seek(buffer.tell() - 1)
-				buffer.truncate()
-			if host.output_buffer.tell() > 0:
-				host.output_buffer.seek(host.output_buffer.tell() - 1)
-				host.output_buffer.truncate()
-		else:
-			# normal character
-			buffer.write(char)
-			host.output_buffer.write(char)
-		# if the length of the buffer is greater than 100, we try to decode the buffer to find if there are any unicode line change chars
-		if buffer.tell() % 100 == 0 and buffer.tell() > 0:
-			try:
-				# try to decode the buffer to find if there are any unicode line change chars
-				decodedLine = buffer.getvalue().decode(_encoding,errors='backslashreplace')
-				lines = decodedLine.splitlines()
-				if len(lines) > 1:
-					# if there are multiple lines, we add them to the target
-					for line in lines[:-1]:
-						# for all lines except the last one, we add them to the target
-						target.append(line)
-						host.output.append(line)
-						host.lineNumToPrintSet.add(len(host.output)-1)
-					# we keep the last line in the buffer
-					buffer.seek(0)
-					buffer.truncate(0)
-					buffer.write(lines[-1].encode(_encoding,errors='backslashreplace'))
-					host.output_buffer.seek(0)
-					host.output_buffer.truncate(0)
-					host.output_buffer.write(lines[-1].encode(_encoding,errors='backslashreplace'))
-				
-			except UnicodeDecodeError:
-				# if there is a unicode decode error, we just skip this character
+	try:
+		for char in iter(lambda:stream.read(1), b''):
+			host.lastUpdateTime = time.monotonic()
+			if char == b'\n':
+				add_line(buffer,target, host)
 				continue
+			elif char == b'\r':
+				buffer.seek(0)
+				host.output_buffer.seek(0)
+			elif char == b'\x08':
+				# backspace
+				if buffer.tell() > 0:
+					buffer.seek(buffer.tell() - 1)
+					buffer.truncate()
+				if host.output_buffer.tell() > 0:
+					host.output_buffer.seek(host.output_buffer.tell() - 1)
+					host.output_buffer.truncate()
+			else:
+				# normal character
+				buffer.write(char)
+				host.output_buffer.write(char)
+			# if the length of the buffer is greater than 100, we try to decode the buffer to find if there are any unicode line change chars
+			if buffer.tell() % 100 == 0 and buffer.tell() > 0:
+				try:
+					# try to decode the buffer to find if there are any unicode line change chars
+					decodedLine = buffer.getvalue().decode(_encoding,errors='backslashreplace')
+					lines = decodedLine.splitlines()
+					if len(lines) > 1:
+						# if there are multiple lines, we add them to the target
+						for line in lines[:-1]:
+							# for all lines except the last one, we add them to the target
+							target.append(line)
+							host.output.append(line)
+							host.lineNumToPrintSet.add(len(host.output)-1)
+						# we keep the last line in the buffer
+						buffer.seek(0)
+						buffer.truncate(0)
+						buffer.write(lines[-1].encode(_encoding,errors='backslashreplace'))
+						host.output_buffer.seek(0)
+						host.output_buffer.truncate(0)
+						host.output_buffer.write(lines[-1].encode(_encoding,errors='backslashreplace'))
+					
+				except UnicodeDecodeError:
+					# if there is a unicode decode error, we just skip this character
+					continue
+	except ValueError:
+		pass
 	if buffer.tell() > 0:
 		# if there is still some data in the buffer, we add it to the target
 		add_line(buffer,target, host)
@@ -1247,7 +1762,7 @@ def __handle_writing_stream(stream,stop_event,host):
 	#     host.output.append(' $ ' + ''.join(__keyPressesIn[-1]).encode().decode().replace('\n', '↵'))
 	#     host.stdout.append(' $ ' + ''.join(__keyPressesIn[-1]).encode().decode().replace('\n', '↵'))
 	return sentInputPos
-	
+
 def run_command(host, sem, timeout=60,passwds=None, retry_limit = 5):
 	'''
 	Run the command on the host. Will format the commands accordingly. Main execution function.
@@ -1266,6 +1781,11 @@ def run_command(host, sem, timeout=60,passwds=None, retry_limit = 5):
 	global __ipmiiInterfaceIPPrefix
 	global _binPaths
 	global __DEBUG_MODE
+	global DEFAULT_IPMI_USERNAME
+	global DEFAULT_IPMI_PASSWORD
+	global DEFAULT_USERNAME
+	global DEFAULT_PASSWORD
+	global SSH_STRICT_HOST_KEY_CHECKING
 	if retry_limit < 0:
 		host.output.append('Error: Retry limit reached!')
 		host.stderr.append('Error: Retry limit reached!')
@@ -1293,6 +1813,7 @@ def run_command(host, sem, timeout=60,passwds=None, retry_limit = 5):
 		host.command = replace_magic_strings(host.command,['#I#'],str(host.i),case_sensitive=False)
 		host.command = replace_magic_strings(host.command,['#PASSWD#','#PASSWORD#'],passwds,case_sensitive=False)
 		host.command = replace_magic_strings(host.command,['#UUID#'],str(host.uuid),case_sensitive=False)
+		host.command = replace_magic_strings(host.command,['#IP#'],str(host.ip),case_sensitive=False)
 		formatedCMD = []
 		if host.extraargs and isinstance(host.extraargs, str):
 			extraargs = host.extraargs.split()
@@ -1309,7 +1830,7 @@ def run_command(host, sem, timeout=60,passwds=None, retry_limit = 5):
 				host.address = '.'.join(prefixOctets[:3]+hostOctets[min(3,len(prefixOctets)):])
 				host.resolvedName = host.username + '@' if host.username else ''
 				host.resolvedName += host.address
-			except:
+			except Exception:
 				host.resolvedName = host.name
 		else:
 			host.resolvedName = host.name
@@ -1321,22 +1842,27 @@ def run_command(host, sem, timeout=60,passwds=None, retry_limit = 5):
 					host.command = host.command.replace('ipmitool ','')
 				elif host.command.startswith(_binPaths['ipmitool']):
 					host.command = host.command.replace(_binPaths['ipmitool'],'')
-				if not host.username:
-					host.username = 'admin'
+				if not host.username or host.username == DEFAULT_USERNAME:
+					if DEFAULT_IPMI_USERNAME:
+						host.username = DEFAULT_IPMI_USERNAME
+					elif DEFAULT_USERNAME:
+						host.username = DEFAULT_USERNAME
+					else:
+						host.username = 'ADMIN'
+				if not passwds or passwds == DEFAULT_PASSWORD:
+					if DEFAULT_IPMI_PASSWORD:
+						passwds = DEFAULT_IPMI_PASSWORD
+					elif DEFAULT_PASSWORD:
+						passwds = DEFAULT_PASSWORD
+					else:
+						host.output.append('Warning: Password not provided for ipmi! Using a default password `admin`.')
+						passwds = 'admin'
 				if not host.command:
 					host.command = 'power status'
 				if 'sh' in _binPaths:
-					if passwds:
-						formatedCMD = [_binPaths['sh'],'-c',f'ipmitool -H {host.address} -U {host.username} -P {passwds} {" ".join(extraargs)} {host.command}']
-					else:
-						host.output.append('Warning: Password not provided for ipmi! Using a default password `admin`.')
-						formatedCMD = [_binPaths['sh'],'-c',f'ipmitool -H {host.address} -U {host.username} -P admin {" ".join(extraargs)} {host.command}']
+					formatedCMD = [_binPaths['sh'],'-c',f'ipmitool -H {host.address} -U {host.username} -P {passwds} {" ".join(extraargs)} {host.command}']
 				else:
-					if passwds:
-						formatedCMD = [_binPaths['ipmitool'],f'-H {host.address}',f'-U {host.username}',f'-P {passwds}'] + extraargs + [host.command]
-					else:
-						host.output.append('Warning: Password not provided for ipmi! Using a default password `admin`.')
-						formatedCMD = [_binPaths['ipmitool'],f'-H {host.address}',f'-U {host.username}',f'-P admin'] + extraargs + [host.command]
+					formatedCMD = [_binPaths['ipmitool'],f'-H {host.address}',f'-U {host.username}',f'-P {passwds}'] + extraargs + [host.command]
 			elif 'ssh' in _binPaths:
 				host.output.append('Ipmitool not found on the local machine! Trying ipmitool on the remote machine...')
 				if __DEBUG_MODE:
@@ -1486,8 +2012,6 @@ def run_command(host, sem, timeout=60,passwds=None, retry_limit = 5):
 			stdout_thread.join(timeout=1)
 			stderr_thread.join(timeout=1)
 			stdin_thread.join(timeout=1)
-			# here we handle the rest of the stdout after the subprocess returns
-			host.output.append(f'Pipe Closed. Trying to read the rest of the stdout...')
 			if not _emo:
 				stdout = None
 				stderr = None
@@ -1496,8 +2020,10 @@ def run_command(host, sem, timeout=60,passwds=None, retry_limit = 5):
 				except subprocess.TimeoutExpired:
 					pass
 				if stdout:
+					host.output.append('Trying to read the rest of the stdout...')
 					__handle_reading_stream(io.BytesIO(stdout),host.stdout, host,host.stdout_buffer)
 				if stderr:
+					host.output.append('Trying to read the rest of the stderr...')
 					__handle_reading_stream(io.BytesIO(stderr),host.stderr, host,host.stderr_buffer)
 				# if the last line in host.stderr is Connection to * closed., we will remove it
 			host.returncode = proc.poll()
@@ -1569,8 +2095,9 @@ def start_run_on_hosts(hosts, timeout=60,password=None,max_connections=4 * os.cp
 		return []
 	sem = threading.Semaphore(max_connections)  # Limit concurrent SSH sessions
 	threads = [threading.Thread(target=run_command, args=(host, sem,timeout,password), daemon=True) for host in hosts]
-	for thread in threads:
+	for thread, host in zip(threads, hosts):
 		thread.start()
+		host.thread = thread
 		time.sleep(__thread_start_delay)
 	return threads
 
@@ -1906,7 +2433,7 @@ def _get_hosts_to_display (hosts, max_num_hosts, hosts_to_display = None, indexO
 			rearrangedHosts.add(host)
 	return new_hosts_to_display , {'running':len(running_hosts), 'failed':len(failed_hosts), 'finished':len(finished_hosts), 'waiting':len(waiting_hosts)}, rearrangedHosts
 
-def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,single_window=DEFAULT_SINGLE_WINDOW, config_reason = 'New Configuration'):
+def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min_char_len = DEFAULT_WINDOW_WIDTH, min_line_len = DEFAULT_WINDOW_HEIGHT,single_window=DEFAULT_SINGLE_WINDOW,help_shown = False, config_reason = 'New Configuration'):
 	global _encoding
 	_ = config_reason
 	try:
@@ -1925,9 +2452,9 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 			min_line_len_local = max_y-1
 		# return True if the terminal is too small
 		if max_x < 2 or max_y < 2:
-			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal too small')
+			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'Terminal too small')
 		if min_char_len_local < 1 or min_line_len_local < 1:
-			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Minimum character or line length too small')
+			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'Minimum character or line length too small')
 		# We need to figure out how many hosts we can fit in the terminal
 		# We will need at least 2 lines per host, one for its name, one for its output
 		# Each line will be at least 61 characters long (60 for the output, 1 for the borders)
@@ -1935,10 +2462,10 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 		max_num_hosts_y = max_y // (min_line_len_local + 1)
 		max_num_hosts = max_num_hosts_x * max_num_hosts_y
 		if max_num_hosts < 1:
-			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal too small to display any hosts')
+			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'Terminal too small to display any hosts')
 		hosts_to_display , host_stats, rearrangedHosts = _get_hosts_to_display(hosts, max_num_hosts)
 		if len(hosts_to_display) == 0:
-			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'No hosts to display')
+			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'No hosts to display')
 		# Now we calculate the actual number of hosts we will display for x and y
 		optimal_len_x = max(min_char_len_local, 80)
 		num_hosts_x = min(max(min(max_num_hosts_x, max_x // optimal_len_x),1),len(hosts_to_display))
@@ -1959,7 +2486,7 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 		host_window_height = max_y // num_hosts_y
 		host_window_width = max_x // num_hosts_x
 		if host_window_height < 1 or host_window_width < 1:
-			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Host window too small')
+			return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'Host window too small')
 
 		old_stat = ''
 		old_bottom_stat = ''
@@ -2020,7 +2547,6 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 		_curses_add_string_to_window(window=help_window,y=12,line='Esc     : Clear line', color_pair_list=[-1,-1,1], lead_str='│', box_ansi_color=box_ansi_color)
 		help_panel = curses.panel.new_panel(help_window)
 		help_panel.hide()
-		help_shown = False
 		curses.panel.update_panels()
 		indexOffset = 0
 		while host_stats['running'] > 0 or host_stats['waiting'] > 0:
@@ -2033,7 +2559,7 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 				# with open('keylog.txt','a') as f:
 				#     f.write(str(key)+'\n')
 				if key == 410 or key == curses.KEY_RESIZE: # 410 is the key code for resize
-					return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal resize requested')    
+					return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'Terminal resize requested')    
 				# if the user pressed ctrl + d and the last line is empty, we will exit by adding 'exit\n' to the last line
 				elif key == 4 and not __keyPressesIn[-1]:
 					__keyPressesIn[-1].extend('exit\n')
@@ -2041,20 +2567,20 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 				elif key == 95 and not __keyPressesIn[-1]: # 95 is the key code for _
 					# if last line is empty, we will reconfigure the wh to be smaller
 					if min_line_len != 1:
-						return (lineToDisplay,curserPosition , min_char_len , max(min_line_len -1,1), single_window, 'Decrease line length')
+						return (lineToDisplay,curserPosition , min_char_len , max(min_line_len -1,1), single_window,help_shown, 'Decrease line length')
 				elif key == 43 and not __keyPressesIn[-1]: # 43 is the key code for +
 					# if last line is empty, we will reconfigure the wh to be larger
-					return (lineToDisplay,curserPosition , min_char_len , min_line_len +1, single_window, 'Increase line length')
+					return (lineToDisplay,curserPosition , min_char_len , min_line_len +1, single_window,help_shown, 'Increase line length')
 				elif key == 123 and not __keyPressesIn[-1]: # 123 is the key code for {
 					# if last line is empty, we will reconfigure the ww to be smaller
 					if min_char_len != 1:
-						return (lineToDisplay,curserPosition , max(min_char_len -1,1), min_line_len, single_window, 'Decrease character length')
+						return (lineToDisplay,curserPosition , max(min_char_len -1,1), min_line_len, single_window,help_shown, 'Decrease character length')
 				elif key == 124 and not __keyPressesIn[-1]: # 124 is the key code for |
 					# if last line is empty, we will toggle the single window mode
-					return (lineToDisplay,curserPosition , min_char_len, min_line_len, not single_window, 'Toggle single window mode')
+					return (lineToDisplay,curserPosition , min_char_len, min_line_len, not single_window,help_shown, 'Toggle single window mode')
 				elif key == 125 and not __keyPressesIn[-1]: # 125 is the key code for }
 					# if last line is empty, we will reconfigure the ww to be larger
-					return (lineToDisplay,curserPosition , min_char_len +1, min_line_len, single_window, 'Increase character length')
+					return (lineToDisplay,curserPosition , min_char_len +1, min_line_len, single_window,help_shown, 'Increase character length')
 				elif key == 60 and not __keyPressesIn[-1]: # 60 is the key code for <
 					indexOffset = (indexOffset - 1 ) % len(hosts)
 				elif key == 62 and not __keyPressesIn[-1]: # 62 is the key code for >
@@ -2089,11 +2615,11 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 					curserPosition = len(__keyPressesIn[lineToDisplay])
 				elif key == curses.KEY_REFRESH or key == curses.KEY_F5 or key == 18: # 18 is the key code for ctrl + R
 					# if the key is refresh, we will refresh the screen
-					return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Refresh requested')
+					return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'Refresh requested')
 				elif key == curses.KEY_EXIT or key == 27: # 27 is the key code for ESC
 					# if the key is exit, we will exit the program
 					return 
-				elif key == curses.KEY_HELP or key == 63 or key == curses.KEY_F1: # 63 is the key code for ?
+				elif key == curses.KEY_HELP or key == 63 or key == curses.KEY_F1 or key == 8: # 63 is the key code for ?, 8 is the key code for backspace
 					# if the key is help, we will display the help message
 					if not help_shown:
 						help_panel.show()
@@ -2136,7 +2662,7 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 						curserPosition += 1
 			# reconfigure when the terminal size changes
 			if org_dim != stdscr.getmaxyx():
-				return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal resize detected')
+				return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'Terminal resize detected')
 			# We generate the aggregated stats if user did not input anything
 			if not __keyPressesIn[lineToDisplay]:
 				#stats = '┍'+ f" Total: {len(hosts)} Running: {host_stats['running']} Failed: {host_stats['failed']} Finished: {host_stats['finished']} Waiting: {host_stats['waiting']}  ww: {min_char_len} wh:{min_line_len} "[:max_x - 2].center(max_x - 2, "━")
@@ -2205,12 +2731,12 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 							# if the line is visible, we will reprint it
 							if visibleLowerBound <= lineNumToReprint <= len(host.output):
 								_curses_add_string_to_window(window=host_window, y=lineNumToReprint + 1, line=host.output[lineNumToReprint], color_pair_list=host.current_color_pair,lead_str='│',keep_top_n_lines=1,box_ansi_color=box_ansi_color,fill_char='')
-					except Exception as e:
+					except Exception:
 						# import traceback
 						# print(str(e).strip())
 						# print(traceback.format_exc().strip())
 						if org_dim != stdscr.getmaxyx():
-							return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, 'Terminal resize detected')
+							return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, 'Terminal resize detected')
 				if host.lastPrintedUpdateTime != host.lastUpdateTime and host.output_buffer.tell() > 0:
 					# this means there is still output in the buffer, we will print it
 					# we will print the output in the window
@@ -2218,14 +2744,17 @@ def __generate_display(stdscr, hosts, lineToDisplay = -1,curserPosition = 0, min
 				host_window.noutrefresh()
 				host.lastPrintedUpdateTime = host.lastUpdateTime
 			hosts_to_display, host_stats,rearrangedHosts = _get_hosts_to_display(hosts, max_num_hosts,hosts_to_display, indexOffset)
+			if help_shown:
+				help_window.touchwin()
+				help_window.noutrefresh()
 			curses.doupdate()
 			last_refresh_time = time.perf_counter()
 	except Exception as e:
 		import traceback
-		return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window, f'Error: {str(e)}',traceback.format_exc())
+		return (lineToDisplay,curserPosition , min_char_len, min_line_len, single_window,help_shown, f'Error: {str(e)}',traceback.format_exc())
 	return None
 
-def curses_print(stdscr, hosts, threads, min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,single_window = DEFAULT_SINGLE_WINDOW):
+def curses_print(stdscr, hosts, threads, min_char_len = DEFAULT_WINDOW_WIDTH, min_line_len = DEFAULT_WINDOW_HEIGHT,single_window = DEFAULT_SINGLE_WINDOW):
 	'''
 	Print the output of the hosts on the screen
 
@@ -2270,9 +2799,9 @@ def curses_print(stdscr, hosts, threads, min_char_len = DEFAULT_CURSES_MINIMUM_C
 		# print if can change color
 		_curses_add_string_to_window(window=stdscr, y=8, line=f"Real color capability: {curses.can_change_color()}", number_of_char_to_write=stdscr.getmaxyx()[1] - 1)
 		stdscr.refresh()
-	except:
+	except Exception:
 		pass
-	params = (-1,0 , min_char_len, min_line_len, single_window,'new config')
+	params = (-1,0 , min_char_len, min_line_len, single_window,False,'new config')
 	while params:
 		params = __generate_display(stdscr, hosts, *params)
 		if not params:
@@ -2283,39 +2812,317 @@ def curses_print(stdscr, hosts, threads, min_char_len = DEFAULT_CURSES_MINIMUM_C
 		# print the current configuration
 		stdscr.clear()
 		try:
-			stdscr.addstr(0, 0, f"{params[5]}, Reloading Configuration: min_char_len={params[2]}, min_line_len={params[3]}, single_window={params[4]} with window size {stdscr.getmaxyx()} and {len(hosts)} hosts...")
-			if len(params) > 6:
+			stdscr.addstr(0, 0, f"{params[6]}, Reloading Configuration: min_char_len={params[2]}, min_line_len={params[3]}, single_window={params[4]} with window size {stdscr.getmaxyx()} and {len(hosts)} hosts...")
+			if len(params) > 7:
 				# traceback is available, print it
 				i = 1
-				for line in params[6].split('\n'):
+				for line in params[7].split('\n'):
 					stdscr.addstr(i, 0, line)
 					i += 1
 			stdscr.refresh()
-		except:
+		except Exception:
 			pass
-		params = params[:5] + ('new config',)
+		params = params[:6] + ('new config',)
 		time.sleep(0.01)
 		#time.sleep(0.25)
 
 #%% ------------ Generate Output Block ----------------
-def generate_output(hosts, usejson = False, greppable = False):
-	global __keyPressesIn
-	global __global_suppress_printout
-	global __encoding
-	if __global_suppress_printout:
+def can_merge(line_bag1, line_bag2, threshold):
+	if threshold > 0.5:
+		samples = itertools.islice(line_bag1, max(int(len(line_bag1) * (1 - threshold)),1))
+		if not line_bag2.intersection(samples):
+			return False
+	return len(line_bag1.intersection(line_bag2)) >= min(len(line_bag1),len(line_bag2)) * threshold
+
+def mergeOutput(merging_hostnames,outputs_by_hostname,output,diff_display_threshold,line_length):
+	#indexes = {hostname: 0 for hostname in merging_hostnames}
+	indexes = Counter({hostname: 0 for hostname in merging_hostnames})
+	working_index_keys = set(merging_hostnames)
+	previousBuddies = set()
+	hostnameWrapper = textwrap.TextWrapper(width=line_length -1, tabsize=4, replace_whitespace=False, drop_whitespace=False, break_on_hyphens=False,initial_indent=' ', subsequent_indent='- ')
+	hostnameWrapper.wordsep_simple_re = re.compile(r'([,]+)')
+	diff_display_item_count = max(1,int(max(map(len, outputs_by_hostname.values())) * (1 - diff_display_threshold)))
+	def get_multiset_index_for_hostname(hostname):
+		index = indexes[hostname]
+		tracking_index = min(index + diff_display_item_count,len(outputs_by_hostname[hostname]))
+		tracking_iter = itertools.islice(outputs_by_hostname[hostname], tracking_index)
+		return [deque(outputs_by_hostname[hostname][index:tracking_index],maxlen=diff_display_item_count),tracking_iter]
+	# futuresChainMap = ChainMap()
+	# class futureDict(UserDict):
+	# 	def __missing__(self, key):
+	# 		value = get_multiset_index_for_hostname(key)
+	# 		self[key] = value
+	# 		# futuresChainMap.maps.append(value[0]._counter)
+	# 		return value
+	# 	# def initializeHostnames(self, hostnames):
+	# 	# 	entries = {hostname: get_multiset_index_for_hostname(hostname) for hostname in hostnames}
+	# 	# 	self.update(entries)
+	# 	# 	futuresChainMap.maps.extend(entry[0]._counter for entry in entries.values())
+	def advance(dict,key):
+		try:
+			value = dict[key]
+			value[0].append(next(value[1]))
+		except StopIteration:
+			try:
+				value[0].popleft()
+			except IndexError:
+				pass
+		except KeyError:
+			pass
+	# futures = futureDict()
+	# for hostname in merging_hostnames:
+	# 	futures[hostname]  # ensure it's initialized
+	futures = {hostname: get_multiset_index_for_hostname(hostname) for hostname in merging_hostnames}
+	currentLines = defaultdict(set)
+	color_cap = get_terminal_color_capability()
+	if color_cap == 'None':
+		green_str = ''
+		reset_str = ''
+	else:
+		green_str = rgb_to_ansi_color_string(*COLOR_PALETTE.get('green', __DEFAULT_COLOR_PALETTE['green']))
+		reset_str = '\033[0m'
+	for hostname in merging_hostnames:
+		currentLines[outputs_by_hostname[hostname][0]].add(hostname)
+	while indexes:
+		defer = False
+		# sorted_working_hostnames = sorted(working_index_keys, key=lambda hn: indexes[hn])
+		golden_hostname = min(working_index_keys, key=indexes.get)
+		golden_index = indexes[golden_hostname]
+		lineToAdd = outputs_by_hostname[golden_hostname][golden_index]
+		# for hostname, index in sorted_working_indexes[1:]:
+		# 	if lineToAdd == outputs_by_hostname[hostname][index]:
+		# 		buddy.add(hostname)
+		# 	else:
+		# 		futureLines,tracking_index = futures[hostname]
+		# 		if lineToAdd in futureLines:
+		# 			for hn in buddy:
+		# 				working_indexes.pop(hn,None)
+		# 			defer = True
+		# 			break
+		buddy = currentLines[lineToAdd].copy()
+		if len(buddy) < len(working_index_keys):
+			# we need to check the futures then
+			# thisCounter = None
+			# if golden_hostname in futures:
+			# 	thisCounter = futures[golden_hostname][0]._counter
+			# 	futuresChainMap.maps.remove(thisCounter)
+			# for hostname in working_index_keys - buddy - set(futures.keys()):
+			# 	futures[hostname] # ensure it's initialized
+			# futures.initializeHostnames(working_index_keys - buddy - futures.keys())
+			if any(lineToAdd in futures[hostname][0] for hostname in working_index_keys - buddy):
+				defer = True
+				working_index_keys -= buddy
+			# if thisCounter is not None:
+			# 	futuresChainMap.maps.append(thisCounter)
+		if not defer:
+			if buddy != previousBuddies:
+				hostnameStr = ','.join(compact_hostnames(buddy))
+				hostnameLines = hostnameWrapper.wrap(hostnameStr)
+				# hostnameLines = [line.ljust(line_length) for line in hostnameLines]
+				if color_cap == 'None':
+					hostnameLines[0] = f"■{hostnameLines[0]}"
+				elif len(buddy) < len(merging_hostnames):
+					color = int_to_unique_ansi_color(hash(hostnameStr))
+					hostnameLines[0] = f"{color}■{hostnameLines[0]}"
+					hostnameLines[-1] += reset_str
+				else:
+					hostnameLines[0] = f"{green_str}■{reset_str}{hostnameLines[0]}"
+				output.extend(hostnameLines)
+				previousBuddies = buddy
+			output.append(lineToAdd)
+			currentLines[lineToAdd].difference_update(buddy)
+			if not currentLines[lineToAdd]:
+				del currentLines[lineToAdd]
+			indexes.update(buddy)
+			for hostname in buddy:
+				# currentLines[lineToAdd].remove(hostname)
+				# if not currentLines[lineToAdd]:
+				# 	del currentLines[lineToAdd]
+				# indexes[hostname] += 1
+				try:
+					currentLines[outputs_by_hostname[hostname][indexes[hostname]]].add(hostname)
+				except IndexError:
+					indexes.pop(hostname, None)
+					futures.pop(hostname, None)
+					# if future:
+					# 	futuresChainMap.maps.remove(future[0]._counter)
+					continue
+				#advance futures
+				advance(futures, hostname)
+			working_index_keys = set(indexes.keys())
+
+def mergeOutputs(outputs_by_hostname, merge_groups, remaining_hostnames, diff_display_threshold, line_length):
+	output = []
+	color_cap = get_terminal_color_capability()
+	if color_cap == 'None':
+		color_line = ''
+		color_reset = ''
+		green_str = ''
+	else:
+		color_line =  rgb_to_ansi_color_string(*COLOR_PALETTE.get('white', __DEFAULT_COLOR_PALETTE['white']))
+		color_reset = '\033[0m'
+		green_str = rgb_to_ansi_color_string(*COLOR_PALETTE.get('green', __DEFAULT_COLOR_PALETTE['green']))
+	output.append(color_line+'─'*(line_length)+color_reset)
+	hostnameWrapper = textwrap.TextWrapper(width=line_length - 1, tabsize=4, replace_whitespace=False, drop_whitespace=False, break_on_hyphens=False,initial_indent=' ', subsequent_indent='- ')
+	hostnameWrapper.wordsep_simple_re = re.compile(r'([,]+)')
+	for merging_hostnames in merge_groups:
+		mergeOutput(merging_hostnames, outputs_by_hostname, output, diff_display_threshold,line_length)
+		output.append(color_line+'─'*(line_length)+color_reset)
+	for hostname in remaining_hostnames:
+		hostnameLines = hostnameWrapper.wrap(','.join(compact_hostnames([hostname])))
+		hostnameLines[0] = f"{green_str}■{color_reset}{hostnameLines[0]}"
+		output.extend(hostnameLines)
+		output.extend(outputs_by_hostname[hostname])
+		output.append(color_line+'─'*(line_length)+color_reset)
+	if output:
+		output.pop()
+	# if output and output[0] and output[0].startswith('├'):
+	# 	output[0] = '┌' + output[0][1:]
+	return output
+
+def pre_merge_hosts(hosts):
+	'''Merge hosts with identical outputs.'''
+	output_groups = defaultdict(list)
+	# Group hosts by their output identity
+	for host in hosts:
+		identity = host.get_output_hash()
+		output_groups[identity].append(host)
+	# Create merged hosts
+	merged_hosts = []
+	for group in output_groups.values():
+		group[0].name = ','.join(compact_hostnames(host.name for host in group))
+		merged_hosts.append(group[0])
+	return merged_hosts
+
+def get_host_raw_output(hosts, terminal_width):
+	outputs_by_hostname = {}
+	line_bag_by_hostname = {}
+	hostnames_by_line_bag_len = {}
+	text_wrapper = textwrap.TextWrapper(width=terminal_width - 1, tabsize=4, replace_whitespace=False, drop_whitespace=False, 
+									 initial_indent=' ', subsequent_indent='-')
+	max_length = 20
+	color_cap = get_terminal_color_capability()
+	if color_cap == 'None':
+		color_reset_str = ''
+		blue_str = ''
+		cyan_str = ''
+		green_str = ''
+		red_str = ''
+	else:
+		color_reset_str = '\033[0m'
+		blue_str = rgb_to_ansi_color_string(*COLOR_PALETTE.get('blue', __DEFAULT_COLOR_PALETTE['blue']))
+		cyan_str = rgb_to_ansi_color_string(*COLOR_PALETTE.get('bright_cyan', __DEFAULT_COLOR_PALETTE['bright_cyan']))
+		green_str = rgb_to_ansi_color_string(*COLOR_PALETTE.get('bright_green', __DEFAULT_COLOR_PALETTE['bright_green']))
+		red_str = rgb_to_ansi_color_string(*COLOR_PALETTE.get('bright_red', __DEFAULT_COLOR_PALETTE['bright_red']))
+	hosts = pre_merge_hosts(hosts)
+	for host in hosts:
+		max_length = max(max_length, len(max(host.name.split(','), key=len)) + 3)
+		hostPrintOut = [f"{cyan_str}█{color_reset_str} EXECUTED COMMAND:"]
+		for line in host.command.splitlines():
+			hostPrintOut.extend(text_wrapper.wrap(line))
+		# hostPrintOut.extend(itertools.chain.from_iterable(text_wrapper.wrap(line) for line in host['command'].splitlines()))
+		lineBag = {(0,host.command)}
+		prevLine = host.command
+		if host.stdout:
+			hostPrintOut.append(f'{blue_str}▓{color_reset_str} STDOUT:')
+			# for line in host.stdout:
+			# 	if len(line) < terminal_width - 2:
+			# 		hostPrintOut.append(f" {line}")
+			# 	else:
+			# 		hostPrintOut.extend(text_wrapper.wrap(line))
+			hostPrintOut.extend(f" {line}" for line in host.stdout)
+			max_length = max(max_length, max(map(len, host.stdout)))
+			# hostPrintOut.extend(text_wrapper.wrap(line) for line in host.stdout)
+			lineBag.add((prevLine,1))
+			lineBag.add((1,host.stdout[0]))
+			if len(host.stdout) > 1:
+				lineBag.update(zip(host.stdout, host.stdout[1:]))
+			lineBag.update(host.stdout)
+			prevLine = host.stdout[-1]
+		if host.stderr:
+			if host.stderr[0].strip().startswith('ssh: connect to host ') and host.stderr[0].strip().endswith('Connection refused'):
+				host.stderr[0] = 'SSH not reachable!'
+			elif host.stderr[-1].strip().endswith('Connection timed out'):
+				host.stderr[-1] = 'SSH connection timed out!'
+			elif host.stderr[-1].strip().endswith('No route to host'):
+				host.stderr[-1] = 'Cannot find host!'
+			if host.stderr:
+				hostPrintOut.append(f'{red_str}▒{color_reset_str} STDERR:')
+				# for line in host.stderr:
+				# 	if len(line) < terminal_width - 2:
+				# 		hostPrintOut.append(f" {line}")
+				# 	else:
+				# 		hostPrintOut.extend(text_wrapper.wrap(line))
+				hostPrintOut.extend(f" {line}" for line in host.stderr)
+				max_length = max(max_length, max(map(len, host.stderr)))
+				lineBag.add((prevLine,2))
+				lineBag.add((2,host.stderr[0]))
+				lineBag.update(host.stderr)
+				if len(host.stderr) > 1:
+					lineBag.update(zip(host.stderr, host.stderr[1:]))
+				prevLine = host.stderr[-1]
+		if host.returncode != 0:
+			codeColor = red_str
+		else:
+			codeColor = green_str
+		hostPrintOut.append(f"{codeColor}░{color_reset_str} RETURN CODE: {host.returncode}")
+		lineBag.add((prevLine,f"{host.returncode}"))
+		outputs_by_hostname[host.name] = hostPrintOut
+		line_bag_by_hostname[host.name] = lineBag
+		hostnames_by_line_bag_len.setdefault(len(lineBag), set()).add(host.name)
+	return outputs_by_hostname, line_bag_by_hostname, hostnames_by_line_bag_len, sorted(hostnames_by_line_bag_len), min(max_length+2,terminal_width)
+
+def form_merge_groups(hostnames_by_line_bag_len, sorted_hostnames_by_line_bag_len_keys, line_bag_by_hostname, diff_display_threshold):
+	merge_groups = []
+	remaining_hostnames = set()
+	for lbl_i, line_bag_len in enumerate(sorted_hostnames_by_line_bag_len_keys):
+		for this_hostname in hostnames_by_line_bag_len.get(line_bag_len, set()).copy():
+			# if this_hostname not in hostnames_by_line_bag_len.get(line_bag_len, set()):
+			# 	continue
+			try:
+				this_line_bag = line_bag_by_hostname.pop(this_hostname)
+				hostnames_by_line_bag_len.get(line_bag_len, set()).discard(this_hostname)
+			except KeyError:
+				continue
+			target_threshold = line_bag_len * (2 - diff_display_threshold)
+			merge_group = []
+			for other_line_bag_len in sorted_hostnames_by_line_bag_len_keys[lbl_i:]:
+				if other_line_bag_len > target_threshold:
+					break
+				# if other_line_bag_len < line_bag_len:
+				# 	continue
+				for other_hostname in hostnames_by_line_bag_len.get(other_line_bag_len, set()).copy():
+					if can_merge(this_line_bag, line_bag_by_hostname[other_hostname], diff_display_threshold):
+						merge_group.append(other_hostname)
+						hostnames_by_line_bag_len[other_line_bag_len].remove(other_hostname)
+						if not hostnames_by_line_bag_len[other_line_bag_len]:
+							del hostnames_by_line_bag_len[other_line_bag_len]
+						del line_bag_by_hostname[other_hostname]
+			if merge_group:
+				merge_group.append(this_hostname)
+				merge_groups.append(merge_group)
+				# del line_bag_by_hostname[this_hostname]
+			else:
+				remaining_hostnames.add(this_hostname)
+	return merge_groups, remaining_hostnames
+
+def generate_output(hosts, usejson = False, greppable = False,quiet = False,encoding = _encoding,keyPressesIn = [[]]):
+	color_cap = get_terminal_color_capability()
+	if quiet:
 		# remove hosts with returncode 0
-		hosts = [dict(host) for host in hosts if host.returncode != 0]
+		hosts = [host for host in hosts if host.returncode != 0]
 		if not hosts:
 			if usejson:
 				return '{"Success": true}'
 			else:
-				return 'Success'
-	else:
-		hosts = [dict(host) for host in hosts]
+				if color_cap == 'None':
+					return 'Success'
+				else:
+					return '\033[32mSuccess\033[0m'
 	if usejson:
 		# [print(dict(host)) for host in hosts]
 		#print(json.dumps([dict(host) for host in hosts],indent=4))
-		rtnStr = json.dumps(hosts,indent=4)
+		rtnStr = json.dumps([dict(host) for host in hosts],indent=4)
 	elif greppable:
 		# transform hosts to a 2d list
 		rtnStr = '*'*80+'\n'
@@ -2323,58 +3130,55 @@ def generate_output(hosts, usejson = False, greppable = False):
 		for host in hosts:
 			#header = f"{host['name']} | rc: {host['returncode']} | "
 			hostAdded = False
-			for line in host['stdout']:
-				rtnList.append([host['name'],f"rc: {host['returncode']}",'stdout',line])
+			for line in host.stdout:
+				rtnList.append([host.name,f"rc: {host.returncode}",'stdout',line])
 				hostAdded = True
-			for line in host['stderr']:
-				rtnList.append([host['name'],f"rc: {host['returncode']}",'stderr',line])
+			for line in host.stderr:
+				rtnList.append([host.name,f"rc: {host.returncode}",'stderr',line])
 				hostAdded = True
 			if not hostAdded:
-				rtnList.append([host['name'],f"rc: {host['returncode']}",'N/A','<EMPTY>'])
+				rtnList.append([host.name,f"rc: {host.returncode}",'N/A','<EMPTY>'])
 			rtnList.append(['','','',''])
 		rtnStr += pretty_format_table(rtnList)
 		rtnStr += '*'*80+'\n'
-		if __keyPressesIn[-1]:
-			CMDsOut = [''.join(cmd).encode(encoding=_encoding,errors='backslashreplace').decode(encoding=_encoding,errors='backslashreplace').replace('\\n', '↵') for cmd in __keyPressesIn if cmd]
+		if keyPressesIn[-1]:
+			CMDsOut = [''.join(cmd).encode(encoding=encoding,errors='backslashreplace').decode(encoding=encoding,errors='backslashreplace').replace('\\n', '↵') for cmd in keyPressesIn if cmd]
 			rtnStr += 'User Inputs: '+ '\nUser Inputs: '.join(CMDsOut)
 			#rtnStr += '\n'
 	else:
-		outputs = {}
-		for host in hosts:
-			hostPrintOut = f"  Command:\n    {host['command']}\n"
-			hostPrintOut += "  stdout:\n    "+'\n    '.join(host['stdout'])
-			if host['stderr']:
-				if host['stderr'][0].strip().startswith('ssh: connect to host ') and host['stderr'][0].strip().endswith('Connection refused'):
-					host['stderr'][0] = 'SSH not reachable!'
-				elif host['stderr'][-1].strip().endswith('Connection timed out'):
-					host['stderr'][-1] = 'SSH connection timed out!'
-				elif host['stderr'][-1].strip().endswith('No route to host'):
-					host['stderr'][-1] = 'Cannot find host!'
-				hostPrintOut += "\n  stderr:\n  "+'\n    '.join(host['stderr'])
-			hostPrintOut += f"\n  return_code: {host['returncode']}"
-			outputs.setdefault(hostPrintOut, set()).add(host['name'])
-		rtnStr = ''
-		for output, hostSet in outputs.items():
-			compact_hosts = sorted(compact_hostnames(hostSet))
-			rtnStr += '*'*80+'\n'
-			if __global_suppress_printout:
-				rtnStr += f'Abnormal returncode produced by {",".join(compact_hosts)}:\n'
-				rtnStr += output+'\n'
+		try:
+			diff_display_threshold = float(DEFAULT_DIFF_DISPLAY_THRESHOLD)
+			if diff_display_threshold < 0 or diff_display_threshold > 1:
+				raise ValueError
+		except Exception:
+			eprint("Warning: diff_display_threshold should be a float between 0 and 1. Setting to default value of 0.9")
+			diff_display_threshold = 0.9
+		
+		color_reset_str = '' if color_cap == 'None' else '\033[0m'
+		white_str = '' if color_cap == 'None' else rgb_to_ansi_color_string(*COLOR_PALETTE.get('white', __DEFAULT_COLOR_PALETTE['white']))
+		terminal_length = get_terminal_size()[0]
+		outputs_by_hostname, line_bag_by_hostname, hostnames_by_line_bag_len, sorted_hostnames_by_line_bag_len_keys, line_length = get_host_raw_output(hosts,terminal_length)
+		merge_groups ,remaining_hostnames = form_merge_groups(hostnames_by_line_bag_len, sorted_hostnames_by_line_bag_len_keys, line_bag_by_hostname, diff_display_threshold)
+		outputs = mergeOutputs(outputs_by_hostname, merge_groups,remaining_hostnames, diff_display_threshold,line_length)
+		if keyPressesIn[-1]:
+			CMDsOut = [''.join(cmd).encode(encoding=encoding,errors='backslashreplace').decode(encoding=encoding,errors='backslashreplace').replace('\\n', '↵') for cmd in keyPressesIn if cmd]
+			outputs.append(color_reset_str + "░ User Inputs:".ljust(line_length,'─'))
+			cmdOut = []
+			for line in CMDsOut:
+				cmdOut.extend(textwrap.wrap(line, width=line_length-1, tabsize=4, replace_whitespace=False, drop_whitespace=False, 
+									 initial_indent=' ', subsequent_indent='-'))
+			outputs.extend(cmdOut)
+			keyPressesIn[-1].clear()
+		if not outputs:
+			if quiet:
+				if color_cap == 'None':
+					return 'Success'
+				else:
+					return '\033[32mSuccess\033[0m'
 			else:
-				rtnStr += f'These hosts: "{",".join(compact_hosts)}" have a response of:\n'
-				rtnStr += output+'\n'
-		if not __global_suppress_printout or outputs:
-			rtnStr += '*'*80+'\n'
-		if __keyPressesIn[-1]:
-			CMDsOut = [''.join(cmd).encode(encoding=_encoding,errors='backslashreplace').decode(encoding=_encoding,errors='backslashreplace').replace('\\n', '↵') for cmd in __keyPressesIn if cmd]
-			#rtnStr += f"Key presses: {''.join(__keyPressesIn).encode('unicode_escape').decode()}\n"
-			#rtnStr += f"Key presses: {__keyPressesIn}\n"
-			rtnStr += "User Inputs: \n  "
-			rtnStr += '\n  '.join(CMDsOut)
-			rtnStr += '\n'
-			__keyPressesIn[-1].clear()
-		if __global_suppress_printout and not outputs:
-			rtnStr += 'Success'
+				rtnStr = ''
+		else:
+			rtnStr = '\n'.join(outputs + [white_str + '─' * (line_length) + color_reset_str])
 	return rtnStr
 
 def print_output(hosts,usejson = False,quiet = False,greppable = False):
@@ -2389,15 +3193,20 @@ def print_output(hosts,usejson = False,quiet = False,greppable = False):
 	Returns:
 		str: The pretty output generated 
 	'''
-	rtnStr = generate_output(hosts,usejson,greppable)
+	global __global_suppress_printout
+	global _encoding
+	global __keyPressesIn
+	for host in hosts:
+		host.output.clear()
+	rtnStr = generate_output(hosts,usejson,greppable,quiet=__global_suppress_printout,encoding=_encoding,keyPressesIn=__keyPressesIn)
 	if not quiet:
 		print(rtnStr)
 	return rtnStr
 
 #%% ------------ Run / Process Hosts Block ----------------
 def processRunOnHosts(timeout, password, max_connections, hosts, returnUnfinished, no_watch, json, called, greppable,
-					  unavailableHosts:dict,willUpdateUnreachableHosts,curses_min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, 
-					  curses_min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,single_window = DEFAULT_SINGLE_WINDOW,
+					  unavailableHosts:dict,willUpdateUnreachableHosts,window_width = DEFAULT_WINDOW_WIDTH, 
+					  window_height = DEFAULT_WINDOW_HEIGHT,single_window = DEFAULT_SINGLE_WINDOW,
 					  unavailable_host_expiry = DEFAULT_UNAVAILABLE_HOST_EXPIRY):
 	global __globalUnavailableHosts
 	global _no_env
@@ -2415,7 +3224,16 @@ def processRunOnHosts(timeout, password, max_connections, hosts, returnUnfinishe
 			if total_sleeped > 0.1:
 				break
 		if any([host.returncode is None for host in hosts]):
-			curses.wrapper(curses_print, hosts, threads, min_char_len = curses_min_char_len, min_line_len = curses_min_line_len, single_window = single_window)
+			try:
+				curses.wrapper(curses_print, hosts, threads, min_char_len = window_width, min_line_len = window_height, single_window = single_window)
+			except Exception:
+				try:
+					os.environ['TERM'] = 'xterm-256color'
+					curses.wrapper(curses_print, hosts, threads, min_char_len = window_width, min_line_len = window_height, single_window = single_window)
+				except Exception as e:
+					eprint(f"Curses print error: {e}")
+					import traceback
+					print(traceback.format_exc())
 	if not returnUnfinished:
 		# wait until all hosts have a return code
 		while any([host.returncode is None for host in hosts]):
@@ -2424,56 +3242,58 @@ def processRunOnHosts(timeout, password, max_connections, hosts, returnUnfinishe
 				sleep_interval *= 1.1
 		for thread in threads:
 			thread.join(timeout=3)
-	# update the unavailable hosts and global unavailable hosts
-	if willUpdateUnreachableHosts:
-		availableHosts = set()
-		for host in hosts:
-			if host.stderr and ('No route to host' in host.stderr[0].strip() or 'Connection timed out' in host.stderr[0].strip() or (host.stderr[-1].strip().startswith('Timeout!') and host.returncode == 124)):
-				unavailableHosts[host.name] =  int(time.monotonic())
-				__globalUnavailableHosts[host.name] =  int(time.monotonic())
-			else:
-				availableHosts.add(host.name)
-				if host.name in unavailableHosts:
-					del unavailableHosts[host.name]
-				if host.name in __globalUnavailableHosts:
-					del __globalUnavailableHosts[host.name]
-		if __DEBUG_MODE:
-			print(f'Unreachable hosts: {unavailableHosts}')
-		try:
-			# check for the old content, only update if the new content is different
-			if not os.path.exists(os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv')):
-				with open(os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv'),'w') as f:
-					f.writelines(f'{host},{expTime}' for host,expTime in unavailableHosts.items())
-			else:
-				oldDic = {}
-				try:
-					with open(os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv'),'r') as f:
-						for line in f:
-							line = line.strip()
-							if line and ',' in line and len(line.split(',')) >= 2 and line.split(',')[0] and line.split(',')[1].isdigit():
-								hostname = line.split(',')[0]
-								expireTime = int(line.split(',')[1])
-								if expireTime < time.monotonic() and hostname not in availableHosts:
-									oldDic[hostname] = expireTime
-				except:
-					pass
-				# add new entries
-				oldDic.update(unavailableHosts)
-				with open(os.path.join(tempfile.gettempdir(),getpass.getuser()+'__multiSSH3_UNAVAILABLE_HOSTS.csv.new'),'w') as f:
-					for key, value in oldDic.items():
-						f.write(f'{key},{value}\n')
-				os.replace(os.path.join(tempfile.gettempdir(),getpass.getuser()+'__multiSSH3_UNAVAILABLE_HOSTS.csv.new'),os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv'))
-		except Exception as e:
-			eprint(f'Error writing to temporary file: {e!r}')
-			import traceback
-			eprint(traceback.format_exc())
-
+		# update the unavailable hosts and global unavailable hosts
+		if willUpdateUnreachableHosts:
+			availableHosts = set()
+			for host in hosts:
+				if host.stderr and ('No route to host' in host.stderr[0].strip() or 'Connection timed out' in host.stderr[0].strip() or (host.stderr[-1].strip().startswith('Timeout!') and host.returncode == 124)):
+					unavailableHosts[host.name] =  int(time.monotonic() + unavailable_host_expiry)
+					__globalUnavailableHosts[host.name] =  int(time.monotonic() + unavailable_host_expiry)
+				else:
+					availableHosts.add(host.name)
+					if host.name in unavailableHosts:
+						del unavailableHosts[host.name]
+					if host.name in __globalUnavailableHosts:
+						del __globalUnavailableHosts[host.name]
+			if __DEBUG_MODE:
+				print(f'Unreachable hosts: {unavailableHosts}')
+			try:
+				# check for the old content, only update if the new content is different
+				if not os.path.exists(os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv')):
+					with open(os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv'),'w') as f:
+						f.writelines(f'{host},{expTime}' for host,expTime in unavailableHosts.items())
+				else:
+					oldDic = {}
+					try:
+						with open(os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv'),'r') as f:
+							for line in f:
+								line = line.strip()
+								if line and ',' in line and len(line.split(',')) >= 2 and line.split(',')[0] and line.split(',')[1].isdigit():
+									hostname = line.split(',')[0]
+									expireTime = int(line.split(',')[1])
+									if expireTime < time.monotonic() and hostname not in availableHosts:
+										oldDic[hostname] = expireTime
+					except Exception:
+						pass
+					# add new entries
+					oldDic.update(unavailableHosts)
+					with open(os.path.join(tempfile.gettempdir(),getpass.getuser()+'__multiSSH3_UNAVAILABLE_HOSTS.csv.new'),'w') as f:
+						for key, value in oldDic.items():
+							f.write(f'{key},{value}\n')
+					os.replace(os.path.join(tempfile.gettempdir(),getpass.getuser()+'__multiSSH3_UNAVAILABLE_HOSTS.csv.new'),os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv'))
+			except Exception as e:
+				eprint(f'Error writing to temporary file: {e!r}')
+				import traceback
+				eprint(traceback.format_exc())
+		if not called:
+			print_output(hosts,json,greppable=greppable)
+	else:
+		__running_threads.update(threads)
 	# print the output, if the output of multiple hosts are the same, we aggragate them
-	if not called:
-		print_output(hosts,json,greppable=greppable)
+
 
 #%% ------------ Stringfy Block ----------------
-@cache_decorator
+
 def formHostStr(host) -> str:
 	"""
 	Forms a comma-separated string of hosts.
@@ -2493,8 +3313,7 @@ def formHostStr(host) -> str:
 	if 'local_shell' in host:
 		host.remove('local_shell')
 		host.add('localhost')
-	host = ','.join(host)
-	return host
+	return ','.join(compact_hostnames(host))
 
 @cache_decorator
 def __formCommandArgStr(oneonone = DEFAULT_ONE_ON_ONE, timeout = DEFAULT_TIMEOUT,password = DEFAULT_PASSWORD,
@@ -2504,37 +3323,66 @@ def __formCommandArgStr(oneonone = DEFAULT_ONE_ON_ONE, timeout = DEFAULT_TIMEOUT
 						 no_env=DEFAULT_NO_ENV,greppable=DEFAULT_GREPPABLE_MODE,skip_hosts = DEFAULT_SKIP_HOSTS,
 						 file_sync = False, error_only = DEFAULT_ERROR_ONLY, identity_file = DEFAULT_IDENTITY_FILE,
 						 copy_id = False, unavailable_host_expiry = DEFAULT_UNAVAILABLE_HOST_EXPIRY, no_history = DEFAULT_NO_HISTORY,
-						 history_file = DEFAULT_HISTORY_FILE, env_file = DEFAULT_ENV_FILE,
+						 history_file = DEFAULT_HISTORY_FILE, env_file = '', env_files = DEFAULT_ENV_FILES,
 						 repeat = DEFAULT_REPEAT,interval = DEFAULT_INTERVAL,
 						 shortend = False) -> str:
 	argsList = []
-	if oneonone: argsList.append('--oneonone' if not shortend else '-11')
-	if timeout and timeout != DEFAULT_TIMEOUT: argsList.append(f'--timeout={timeout}' if not shortend else f'-t={timeout}')
-	if repeat and repeat != DEFAULT_REPEAT: argsList.append(f'--repeat={repeat}' if not shortend else f'-r={repeat}')
-	if interval and interval != DEFAULT_INTERVAL: argsList.append(f'--interval={interval}' if not shortend else f'-i={interval}')
-	if password and password != DEFAULT_PASSWORD: argsList.append(f'--password="{password}"' if not shortend else f'-p="{password}"')
-	if identity_file and identity_file != DEFAULT_IDENTITY_FILE: argsList.append(f'--key="{identity_file}"' if not shortend else f'-k="{identity_file}"')
-	if copy_id: argsList.append('--copy_id' if not shortend else '-ci')
-	if no_watch: argsList.append('--no_watch' if not shortend else '-q')
-	if json: argsList.append('--json' if not shortend else '-j')
-	if max_connections and max_connections != DEFAULT_MAX_CONNECTIONS: argsList.append(f'--max_connections={max_connections}' if not shortend else f'-m={max_connections}')
-	if files: argsList.extend([f'--file="{file}"' for file in files] if not shortend else [f'-f="{file}"' for file in files])
-	if ipmi: argsList.append('--ipmi')
-	if interface_ip_prefix and interface_ip_prefix != DEFAULT_INTERFACE_IP_PREFIX: argsList.append(f'--interface_ip_prefix="{interface_ip_prefix}"' if not shortend else f'-pre="{interface_ip_prefix}"')
-	if scp: argsList.append('--scp')
-	if gather_mode: argsList.append('--gather_mode' if not shortend else '-gm')
-	if username and username != DEFAULT_USERNAME: argsList.append(f'--username="{username}"' if not shortend else f'-u="{username}"')
-	if extraargs and extraargs != DEFAULT_EXTRA_ARGS: argsList.append(f'--extraargs="{extraargs}"' if not shortend else f'-ea="{extraargs}"')
-	if skipUnreachable: argsList.append('--skip_unreachable' if not shortend else '-su')
-	if unavailable_host_expiry and unavailable_host_expiry != DEFAULT_UNAVAILABLE_HOST_EXPIRY: argsList.append(f'--unavailable_host_expiry={unavailable_host_expiry}' if not shortend else f'-uhe={unavailable_host_expiry}')
-	if no_env: argsList.append('--no_env')
-	if env_file and env_file != DEFAULT_ENV_FILE: argsList.append(f'--env_file="{env_file}"' if not shortend else f'-ef="{env_file}"')
-	if no_history: argsList.append('--no_history' if not shortend else '-nh')
-	if history_file and history_file != DEFAULT_HISTORY_FILE: argsList.append(f'--history_file="{history_file}"' if not shortend else f'-hf="{history_file}"')
-	if greppable: argsList.append('--greppable' if not shortend else '-g')
-	if error_only: argsList.append('--error_only' if not shortend else '-eo')
-	if skip_hosts and skip_hosts != DEFAULT_SKIP_HOSTS: argsList.append(f'--skip_hosts="{skip_hosts}"' if not shortend else f'-sh="{skip_hosts}"')
-	if file_sync: argsList.append('--file_sync' if not shortend else '-fs')
+	if oneonone:
+		argsList.append('--oneonone' if not shortend else '-11')
+	if timeout and timeout != DEFAULT_TIMEOUT:
+		argsList.append(f'--timeout={timeout}' if not shortend else f'-t={timeout}')
+	if repeat and repeat != DEFAULT_REPEAT:
+		argsList.append(f'--repeat={repeat}' if not shortend else f'-r={repeat}')
+	if interval and interval != DEFAULT_INTERVAL:
+		argsList.append(f'--interval={interval}' if not shortend else f'-i={interval}')
+	if password and password != DEFAULT_PASSWORD:
+		argsList.append(f'--password="{password}"' if not shortend else f'-p="{password}"')
+	if identity_file and identity_file != DEFAULT_IDENTITY_FILE:
+		argsList.append(f'--key="{identity_file}"' if not shortend else f'-k="{identity_file}"')
+	if copy_id:
+		argsList.append('--copy_id' if not shortend else '-ci')
+	if no_watch:
+		argsList.append('--no_watch' if not shortend else '-q')
+	if json:
+		argsList.append('--json' if not shortend else '-j')
+	if max_connections and max_connections != DEFAULT_MAX_CONNECTIONS:
+		argsList.append(f'--max_connections={max_connections}' if not shortend else f'-m={max_connections}')
+	if files:
+		argsList.extend([f'--file="{file}"' for file in files] if not shortend else [f'-f="{file}"' for file in files])
+	if ipmi:
+		argsList.append('--ipmi')
+	if interface_ip_prefix and interface_ip_prefix != DEFAULT_INTERFACE_IP_PREFIX:
+		argsList.append(f'--interface_ip_prefix="{interface_ip_prefix}"' if not shortend else f'-pre="{interface_ip_prefix}"')
+	if scp:
+		argsList.append('--scp')
+	if gather_mode:
+		argsList.append('--gather_mode' if not shortend else '-gm')
+	if username and username != DEFAULT_USERNAME:
+		argsList.append(f'--username="{username}"' if not shortend else f'-u="{username}"')
+	if extraargs and extraargs != DEFAULT_EXTRA_ARGS:
+		argsList.append(f'--extraargs="{extraargs}"' if not shortend else f'-ea="{extraargs}"')
+	if skipUnreachable:
+		argsList.append('--skip_unreachable' if not shortend else '-su')
+	if unavailable_host_expiry and unavailable_host_expiry != DEFAULT_UNAVAILABLE_HOST_EXPIRY:
+		argsList.append(f'--unavailable_host_expiry={unavailable_host_expiry}' if not shortend else f'-uhe={unavailable_host_expiry}')
+	if no_env:
+		argsList.append('--no_env')
+	if env_file:
+		argsList.append(f'--env_file="{env_file}"' if not shortend else f'-ef="{env_file}"')
+	if env_files:
+		argsList.extend([f'--env_files="{ef}"' for ef in env_files] if not shortend else [f'-efs="{ef}"' for ef in env_files])
+	if no_history:
+		argsList.append('--no_history' if not shortend else '-nh')
+	if history_file and history_file != DEFAULT_HISTORY_FILE:
+		argsList.append(f'--history_file="{history_file}"' if not shortend else f'-hf="{history_file}"')
+	if greppable:
+		argsList.append('--greppable' if not shortend else '-g')
+	if error_only:
+		argsList.append('--error_only' if not shortend else '-eo')
+	if skip_hosts and skip_hosts != DEFAULT_SKIP_HOSTS:
+		argsList.append(f'--skip_hosts="{skip_hosts}"' if not shortend else f'-sh="{skip_hosts}"')
+	if file_sync:
+		argsList.append('--file_sync' if not shortend else '-fs')
 	return ' '.join(argsList)
 
 def getStrCommand(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAULT_ONE_ON_ONE, timeout = DEFAULT_TIMEOUT,password = DEFAULT_PASSWORD,
@@ -2542,18 +3390,18 @@ def getStrCommand(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAULT_ONE_O
 						 files = None,ipmi = DEFAULT_IPMI,interface_ip_prefix = DEFAULT_INTERFACE_IP_PREFIX,returnUnfinished = _DEFAULT_RETURN_UNFINISHED,
 						 scp=DEFAULT_SCP,gather_mode = False,username=DEFAULT_USERNAME,extraargs=DEFAULT_EXTRA_ARGS,skipUnreachable=DEFAULT_SKIP_UNREACHABLE,
 						 no_env=DEFAULT_NO_ENV,greppable=DEFAULT_GREPPABLE_MODE,willUpdateUnreachableHosts=_DEFAULT_UPDATE_UNREACHABLE_HOSTS,no_start=_DEFAULT_NO_START,
-						 skip_hosts = DEFAULT_SKIP_HOSTS, curses_min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, curses_min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,
+						 skip_hosts = DEFAULT_SKIP_HOSTS, window_width = DEFAULT_WINDOW_WIDTH, window_height = DEFAULT_WINDOW_HEIGHT,
 						 single_window = DEFAULT_SINGLE_WINDOW,file_sync = False,error_only = DEFAULT_ERROR_ONLY, identity_file = DEFAULT_IDENTITY_FILE,
 						 copy_id = False, unavailable_host_expiry = DEFAULT_UNAVAILABLE_HOST_EXPIRY,no_history = DEFAULT_NO_HISTORY,
-						 history_file = DEFAULT_HISTORY_FILE, env_file = DEFAULT_ENV_FILE,
+						 history_file = DEFAULT_HISTORY_FILE, env_file = '', env_files = [],
 						 repeat = DEFAULT_REPEAT,interval = DEFAULT_INTERVAL,
-						 shortend = False,tabSeperated = False):
+						 shortend = False,tabSeperated = False,**kwargs) -> str:
 	_ = called
 	_ = returnUnfinished
 	_ = willUpdateUnreachableHosts
 	_ = no_start
-	_ = curses_min_char_len
-	_ = curses_min_line_len
+	_ = window_width
+	_ = window_height
 	_ = single_window
 	hosts = hosts if isinstance(hosts,str) else frozenset(hosts)
 	hostStr = formHostStr(hosts)
@@ -2565,10 +3413,10 @@ def getStrCommand(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAULT_ONE_O
 						 no_env=no_env, greppable=greppable,skip_hosts = skip_hosts, 
 						 file_sync = file_sync,error_only = error_only, identity_file = identity_file,
 						 copy_id = copy_id, unavailable_host_expiry =unavailable_host_expiry,no_history = no_history,
-						 history_file = history_file, env_file = env_file,
+						 history_file = history_file, env_file = env_file, env_files = env_files,
 						 repeat = repeat,interval = interval,
 						 shortend = shortend)
-	commands = [command.replace('"', '\\"').replace('\n', '\\n').replace('\t', '\\t') for command in commands]
+	commands = [command.replace('"', '\\"').replace('\n', '\\n').replace('\t', '\\t') for command in format_commands(commands)]
 	commandStr = '"' + '" "'.join(commands) + '"' if commands else ''
 	filePath = os.path.abspath(__file__)
 	programName = filePath if filePath else 'mssh'
@@ -2616,56 +3464,56 @@ def record_command_history(kwargs):
 #%% ------------ Main Block ----------------
 def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAULT_ONE_ON_ONE, timeout = DEFAULT_TIMEOUT,password = DEFAULT_PASSWORD,
 						 no_watch = DEFAULT_NO_WATCH,json = DEFAULT_JSON_MODE,called = _DEFAULT_CALLED,max_connections=DEFAULT_MAX_CONNECTIONS,
-						 files = None,ipmi = DEFAULT_IPMI,interface_ip_prefix = DEFAULT_INTERFACE_IP_PREFIX,returnUnfinished = _DEFAULT_RETURN_UNFINISHED,
+						 file = None,ipmi = DEFAULT_IPMI,interface_ip_prefix = DEFAULT_INTERFACE_IP_PREFIX,returnUnfinished = _DEFAULT_RETURN_UNFINISHED,
 						 scp=DEFAULT_SCP,gather_mode = False,username=DEFAULT_USERNAME,extraargs=DEFAULT_EXTRA_ARGS,skipUnreachable=DEFAULT_SKIP_UNREACHABLE,
 						 no_env=DEFAULT_NO_ENV,greppable=DEFAULT_GREPPABLE_MODE,willUpdateUnreachableHosts=_DEFAULT_UPDATE_UNREACHABLE_HOSTS,no_start=_DEFAULT_NO_START,
-						 skip_hosts = DEFAULT_SKIP_HOSTS, curses_min_char_len = DEFAULT_CURSES_MINIMUM_CHAR_LEN, curses_min_line_len = DEFAULT_CURSES_MINIMUM_LINE_LEN,
+						 skip_hosts = DEFAULT_SKIP_HOSTS, window_width = DEFAULT_WINDOW_WIDTH, window_height = DEFAULT_WINDOW_HEIGHT,
 						 single_window = DEFAULT_SINGLE_WINDOW,file_sync = False,error_only = DEFAULT_ERROR_ONLY,quiet = False,identity_file = DEFAULT_IDENTITY_FILE,
 						 copy_id = False, unavailable_host_expiry = DEFAULT_UNAVAILABLE_HOST_EXPIRY,no_history = True,
-						 history_file = DEFAULT_HISTORY_FILE,
+						 history_file = DEFAULT_HISTORY_FILE,**kwargs
 						 ):
-	f'''
-	Run the command on the hosts, aka multissh. main function
-
-	Args:
-		hosts (str/iterable): A string of hosts seperated by space or comma / iterable of hosts. Default to {DEFAULT_HOSTS}.
-		commands (list): A list of commands to run on the hosts. When using files, defines the destination of the files. Defaults to None.
-		oneonone (bool, optional): Whether to run the commands one on one. Defaults to {DEFAULT_ONE_ON_ONE}.
-		timeout (int, optional): The timeout for the command. Defaults to {DEFAULT_TIMEOUT}.
-		password (str, optional): The password for the hosts. Defaults to {DEFAULT_PASSWORD}.
-		no_watch (bool, optional): Whether to print the output. Defaults to {DEFAULT_NO_WATCH}.
-		json (bool, optional): Whether to print the output in JSON format. Defaults to {DEFAULT_JSON_MODE}.
-		called (bool, optional): Whether the function is called by another function. Defaults to {_DEFAULT_CALLED}.
-		max_connections (int, optional): The maximum number of concurrent SSH sessions. Defaults to 4 * os.cpu_count().
-		files (list, optional): A list of files to be copied to the hosts. Defaults to None.
-		ipmi (bool, optional): Whether to use IPMI to connect to the hosts. Defaults to {DEFAULT_IPMI}.
-		interface_ip_prefix (str, optional): The prefix of the IPMI interface. Defaults to {DEFAULT_INTERFACE_IP_PREFIX}.
-		returnUnfinished (bool, optional): Whether to return the unfinished hosts. Defaults to {_DEFAULT_RETURN_UNFINISHED}.
-		scp (bool, optional): Whether to use scp instead of rsync. Defaults to {DEFAULT_SCP}.
-		gather_mode (bool, optional): Whether to use gather mode. Defaults to False.
-		username (str, optional): The username to use to connect to the hosts. Defaults to {DEFAULT_USERNAME}.
-		extraargs (str, optional): Extra arguments to pass to the ssh / rsync / scp command. Defaults to {DEFAULT_EXTRA_ARGS}.
-		skipUnreachable (bool, optional): Whether to skip unreachable hosts. Defaults to {DEFAULT_SKIP_UNREACHABLE}.
-		no_env (bool, optional): Whether to not read the current sat system environment variables. (Will still read from files) Defaults to {DEFAULT_NO_ENV}.
-		greppable (bool, optional): Whether to print the output in greppable format. Defaults to {DEFAULT_GREPPABLE_MODE}.
-		willUpdateUnreachableHosts (bool, optional): Whether to update the global unavailable hosts. Defaults to {_DEFAULT_UPDATE_UNREACHABLE_HOSTS}.
-		no_start (bool, optional): Whether to return the hosts without starting the command. Defaults to {_DEFAULT_NO_START}.
-		skip_hosts (str, optional): The hosts to skip. Defaults to {DEFAULT_SKIP_HOSTS}.
-		min_char_len (int, optional): The minimum character per line of the curses output. Defaults to {DEFAULT_CURSES_MINIMUM_CHAR_LEN}.
-		min_line_len (int, optional): The minimum line number for each window of the curses output. Defaults to {DEFAULT_CURSES_MINIMUM_LINE_LEN}.
-		single_window (bool, optional): Whether to use a single window for the curses output. Defaults to {DEFAULT_SINGLE_WINDOW}.
-		file_sync (bool, optional): Whether to use file sync mode to sync directories. Defaults to {DEFAULT_FILE_SYNC}.
-		error_only (bool, optional): Whether to only print the error output. Defaults to {DEFAULT_ERROR_ONLY}.
-		quiet (bool, optional): Whether to suppress all verbose printout, added for compatibility, avoid using. Defaults to False.
-		identity_file (str, optional): The identity file to use for the ssh connection. Defaults to {DEFAULT_IDENTITY_FILE}.
-		copy_id (bool, optional): Whether to copy the id to the hosts. Defaults to False.
-		unavailable_host_expiry (int, optional): The time in seconds to keep the unavailable hosts in the global unavailable hosts. Defaults to {DEFAULT_UNAVAILABLE_HOST_EXPIRY}.
-		no_history (bool, optional): Whether to not save the history of the command. Defaults to True.
-		history_file (str, optional): The file to save the history of the command. Defaults to {DEFAULT_HISTORY_FILE}.
+	"""
+	Run commands on multiple hosts via SSH or IPMI.
+
+	Parameters:
+		hosts (str or iterable): Hosts to run the command on. Can be a string (comma/space-separated) or iterable. Default: DEFAULT_HOSTS.
+		commands (list or None): List of commands to run on the hosts. If files are used, defines the destination. Default: None.
+		oneonone (bool): If True, run each command on the corresponding host (1:1 mapping). Default: DEFAULT_ONE_ON_ONE.
+		timeout (int): Timeout for each command in seconds. Default: DEFAULT_TIMEOUT.
+		password (str): Password for SSH/IPMI authentication. Default: DEFAULT_PASSWORD.
+		no_watch (bool): If True, do not use curses TUI; just print output. Default: DEFAULT_NO_WATCH.
+		json (bool): If True, output results in JSON format. Default: DEFAULT_JSON_MODE.
+		called (bool): If True, function is called programmatically (not CLI). Default: _DEFAULT_CALLED.
+		max_connections (int): Maximum concurrent SSH sessions. Default: 4 * os.cpu_count().
+		file (list or None): Files to copy to hosts. Default: None.
+		ipmi (bool): Use IPMI instead of SSH. Default: DEFAULT_IPMI.
+		interface_ip_prefix (str or None): Override IP prefix for host connection. Default: DEFAULT_INTERFACE_IP_PREFIX.
+		returnUnfinished (bool): If True, return hosts even if not finished. Default: _DEFAULT_RETURN_UNFINISHED.
+		scp (bool): Use scp for file transfer (instead of rsync). Default: DEFAULT_SCP.
+		gather_mode (bool): Gather files from hosts (pull mode). Default: False.
+		username (str or None): Username for SSH/IPMI. Default: DEFAULT_USERNAME.
+		extraargs (str or list or None): Extra args for SSH/SCP/rsync. Default: DEFAULT_EXTRA_ARGS.
+		skipUnreachable (bool): Skip hosts marked as unreachable. Default: DEFAULT_SKIP_UNREACHABLE.
+		no_env (bool): Do not load environment variables from shell. Default: DEFAULT_NO_ENV.
+		greppable (bool): Output in greppable table format. Default: DEFAULT_GREPPABLE_MODE.
+		willUpdateUnreachableHosts (bool): Update global unreachable hosts file. Default: _DEFAULT_UPDATE_UNREACHABLE_HOSTS.
+		no_start (bool): If True, return Host objects without running commands. Default: _DEFAULT_NO_START.
+		skip_hosts (str or None): Hosts to skip. Default: DEFAULT_SKIP_HOSTS.
+		window_width (int): Minimum width per curses window. Default: DEFAULT_WINDOW_WIDTH.
+		window_height (int): Minimum height per curses window. Default: DEFAULT_WINDOW_HEIGHT.
+		single_window (bool): Use a single curses window for all hosts. Default: DEFAULT_SINGLE_WINDOW.
+		file_sync (bool): Enable file sync mode (sync directories). Default: DEFAULT_FILE_SYNC.
+		error_only (bool): Only print error output. Default: DEFAULT_ERROR_ONLY.
+		quiet (bool): Suppress all output (overrides other output options). Default: False.
+		identity_file (str or None): SSH identity file. Default: DEFAULT_IDENTITY_FILE.
+		copy_id (bool): Use ssh-copy-id to copy public key to hosts. Default: False.
+		unavailable_host_expiry (int): Seconds to keep hosts marked as unavailable. Default: DEFAULT_UNAVAILABLE_HOST_EXPIRY.
+		no_history (bool): Do not record command history. Default: True.
+		history_file (str): File to store command history. Default: DEFAULT_HISTORY_FILE.
 
 	Returns:
-		list: A list of Host objects
-	'''
+		list: List of Host objects representing each host/command run.
+	"""
 	global __globalUnavailableHosts
 	global __global_suppress_printout
 	global _no_env
@@ -2694,7 +3542,7 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 						if line and ',' in line and len(line.split(',')) >= 2 and line.split(',')[0] and line.split(',')[1].isdigit():
 							hostname = line.split(',')[0]
 							expireTime = int(line.split(',')[1])
-							if expireTime < time.monotonic() and expireTime + unavailable_host_expiry > time.monotonic():
+							if expireTime > time.monotonic():
 								__globalUnavailableHosts[hostname] = expireTime
 								readed = True
 			if readed and not __global_suppress_printout:
@@ -2703,7 +3551,7 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 			eprint(f"Warning: Unable to read the unavailable hosts from the file {os.path.join(tempfile.gettempdir(),f'__{getpass.getuser()}_multiSSH3_UNAVAILABLE_HOSTS.csv')!r}")
 			eprint(str(e))
 	elif '__multiSSH3_UNAVAILABLE_HOSTS' in readEnvFromFile():
-		__globalUnavailableHosts.update({host: int(time.monotonic()) for host in readEnvFromFile()['__multiSSH3_UNAVAILABLE_HOSTS'].split(',') if host})
+		__globalUnavailableHosts.update({host: int(time.monotonic()+ unavailable_host_expiry) for host in readEnvFromFile()['__multiSSH3_UNAVAILABLE_HOSTS'].split(',') if host})
 	if not max_connections:
 		max_connections = 4 * os.cpu_count()
 	elif max_connections == 0:
@@ -2717,15 +3565,7 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 		if max_connections > __max_connections_nofile_limit_supported * 2:
 			# we need to throttle thread start to avoid hitting the nofile limit
 			__thread_start_delay = 0.001
-	if not commands:
-		commands = []
-	else:
-		commands = [commands] if isinstance(commands,str) else commands
-		# reformat commands into a list of strings, join the iterables if they are not strings
-		try:
-			commands = [' '.join(command) if not isinstance(command,str) else command for command in commands]
-		except:
-			eprint(f"Warning: commands should ideally be a list of strings. Now mssh had failed to convert {commands!r} to a list of strings. Continuing anyway but expect failures.")
+	commands = format_commands(commands)
 	#verify_ssh_config()
 	# load global unavailable hosts only if the function is called (so using --repeat will not load the unavailable hosts again)
 	if called:
@@ -2777,13 +3617,14 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 	skipHostsDic = expand_hostnames(skipHostStr.split(','))
 	skipHostSet = set(skipHostsDic).union(skipHostsDic.values())
 	if skipHostSet:
-		eprint(f"Skipping hosts: \"{' '.join(sorted(compact_hostnames(skipHostSet)))}\"")
+		eprint(f"Skipping hosts: \"{' '.join(compact_hostnames(skipHostSet))}\"")
 	if copy_id:
 		if 'ssh-copy-id' in _binPaths:
 			# we will copy the id to the hosts
 			hosts = []
 			for host in targetHostDic:
-				if host in skipHostSet or targetHostDic[host] in skipHostSet: continue
+				if host in skipHostSet or targetHostDic[host] in skipHostSet:
+					continue
 				command = f"{_binPaths['ssh-copy-id']} "
 				if identity_file:
 					command = f"{command}-i {identity_file} "
@@ -2800,39 +3641,39 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 				processRunOnHosts(timeout=timeout, password=password, max_connections=max_connections, hosts=hosts,
 					   returnUnfinished=returnUnfinished, no_watch=no_watch, json=json, called=called, greppable=greppable,
 					   unavailableHosts=unavailableHosts,willUpdateUnreachableHosts=willUpdateUnreachableHosts,
-					   curses_min_char_len = curses_min_char_len, curses_min_line_len = curses_min_line_len,
+					   window_width = window_width, window_height = window_height,
 					   single_window=single_window,unavailable_host_expiry=unavailable_host_expiry)
 		else:
 			eprint(f"Warning: ssh-copy-id not found in {_binPaths} , skipping copy id to the hosts")
 		if not commands:
 			_exit_with_code(0, "Copy id finished, no commands to run")
-	if files and not commands:
+	if file and not commands:
 		# if files are specified but not target dir, we default to file sync mode
 		file_sync = True
 	if file_sync:
 		# set the files to the union of files and commands
-		files = set(files+commands) if files else set(commands)
-	if files:
+		file = set(file+commands) if file else set(commands)
+	if file:
 		# try to resolve files first (like * etc)
 		if not gather_mode:
 			pathSet = set()
-			for file in files:
+			for file in file:
 				try:
 					pathSet.update(glob.glob(file,include_hidden=True,recursive=True))
-				except:
+				except Exception:
 					pathSet.update(glob.glob(file,recursive=True))
 			if not pathSet:
-				_exit_with_code(66, f'No source files at {files!r} are found after resolving globs!')
+				_exit_with_code(66, f'No source files at {file!r} are found after resolving globs!')
 		else:
-			pathSet = set(files)
+			pathSet = set(file)
 		if file_sync:
 			# use abosolute path for file sync
 			commands = [os.path.abspath(file) for file in pathSet]
-			files = []
+			file = []
 		else:
-			files = list(pathSet)
+			file = list(pathSet)
 		if __DEBUG_MODE:
-			eprint(f"Files: {files!r}")
+			eprint(f"Files: {file!r}")
 	if oneonone:
 		hosts = []
 		if len(commands) != len(set(targetHostDic) - set(skipHostSet)):
@@ -2844,22 +3685,24 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 			eprint('-'*80)
 			eprint("Running in one on one mode")
 		for host, command in zip(targetHostDic, commands):
-			if not ipmi and skipUnreachable and host in unavailableHosts:
+			if not ipmi and skipUnreachable and host in unavailableHosts and unavailableHosts[host] > time.monotonic():
 				eprint(f"Skipping unavailable host: {host}")
 				continue
-			if host in skipHostSet or targetHostDic[host] in skipHostSet: continue
+			if host in skipHostSet or targetHostDic[host] in skipHostSet:
+				continue
 			if file_sync:
 				hosts.append(Host(host, os.path.dirname(command)+os.path.sep, files = [command],ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip = targetHostDic[host]))
 			else:
-				hosts.append(Host(host, command, files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip=targetHostDic[host]))
+				hosts.append(Host(host, command, files = file,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip=targetHostDic[host]))
 			if not __global_suppress_printout: 
 				eprint(f"Running command: {command!r} on host: {host!r}")
-		if not __global_suppress_printout: eprint('-'*80)
+		if not __global_suppress_printout:
+			eprint('-'*80)
 		if not no_start: 
 			processRunOnHosts(timeout=timeout, password=password, max_connections=max_connections, hosts=hosts,
 					  returnUnfinished=returnUnfinished, no_watch=no_watch, json=json, called=called, greppable=greppable,
 					  unavailableHosts=unavailableHosts,willUpdateUnreachableHosts=willUpdateUnreachableHosts,
-					  curses_min_char_len = curses_min_char_len, curses_min_line_len = curses_min_line_len,
+					  window_width = window_width, window_height = window_height,
 					  single_window=single_window,unavailable_host_expiry=unavailable_host_expiry)
 		return hosts
 	else:
@@ -2868,41 +3711,45 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 			# run in interactive mode ssh mode
 			hosts = []
 			for host in targetHostDic:
-				if not ipmi and skipUnreachable and host in unavailableHosts:
-					if not __global_suppress_printout: print(f"Skipping unavailable host: {host}")
+				if not ipmi and skipUnreachable and host in unavailableHosts and unavailableHosts[host] > time.monotonic():
+					if not __global_suppress_printout:
+						print(f"Skipping unavailable host: {host}")
+					continue
+				if host in skipHostSet or targetHostDic[host] in skipHostSet:
 					continue
-				if host in skipHostSet or targetHostDic[host] in skipHostSet: continue
 				if file_sync:
-					eprint(f"Error: file sync mode need to be specified with at least one path to sync.")
+					eprint("Error: file sync mode need to be specified with at least one path to sync.")
 					return []
-				elif files:
-					eprint(f"Error: files need to be specified with at least one path to sync")
+				elif file:
+					eprint("Error: files need to be specified with at least one path to sync")
 				else:
-					hosts.append(Host(host, '', files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,identity_file=identity_file,ip=targetHostDic[host]))
+					hosts.append(Host(host, '', files = file,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,identity_file=identity_file,ip=targetHostDic[host]))
 			if not __global_suppress_printout:
 				eprint('-'*80)
 				eprint(f"Running in interactive mode on hosts: {hostStr}" + (f"; skipping: {skipHostStr}" if skipHostStr else ''))
 				eprint('-'*80)
 			if no_start:
-				eprint(f"Warning: no_start is set, the command will not be started. As we are in interactive mode, no action will be done.")
+				eprint("Warning: no_start is set, the command will not be started. As we are in interactive mode, no action will be done.")
 			else:
 				processRunOnHosts(timeout=timeout, password=password, max_connections=max_connections, hosts=hosts,
 					   returnUnfinished=returnUnfinished, no_watch=no_watch, json=json, called=called, greppable=greppable,
 					   unavailableHosts=unavailableHosts,willUpdateUnreachableHosts=willUpdateUnreachableHosts,
-					   curses_min_char_len = curses_min_char_len, curses_min_line_len = curses_min_line_len,
+					   window_width = window_width, window_height = window_height,
 					   single_window=single_window,unavailable_host_expiry=unavailable_host_expiry)
 			return hosts
 		for command in commands:
 			hosts = []
 			for host in targetHostDic:
-				if not ipmi and skipUnreachable and host in unavailableHosts:
-					if not __global_suppress_printout: print(f"Skipping unavailable host: {host}")
+				if not ipmi and skipUnreachable and host in unavailableHosts and unavailableHosts[host] > time.monotonic():
+					if not __global_suppress_printout:
+						print(f"Skipping unavailable host: {host}")
+					continue
+				if host in skipHostSet or targetHostDic[host] in skipHostSet:
 					continue
-				if host in skipHostSet or targetHostDic[host] in skipHostSet: continue
 				if file_sync:
 					hosts.append(Host(host, os.path.dirname(command)+os.path.sep, files = [command],ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip=targetHostDic[host]))
 				else:
-					hosts.append(Host(host, command, files = files,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip=targetHostDic[host]))
+					hosts.append(Host(host, command, files = file,ipmi=ipmi,interface_ip_prefix=interface_ip_prefix,scp=scp,extraargs=extraargs,gatherMode=gather_mode,identity_file=identity_file,ip=targetHostDic[host]))
 			if not __global_suppress_printout and len(commands) > 1:
 				eprint('-'*80)
 				eprint(f"Running command: {command} on hosts: {hostStr}" + (f"; skipping: {skipHostStr}" if skipHostStr else ''))
@@ -2911,7 +3758,7 @@ def run_command_on_hosts(hosts = DEFAULT_HOSTS,commands = None,oneonone = DEFAUL
 				processRunOnHosts(timeout=timeout, password=password, max_connections=max_connections, hosts=hosts,
 					   returnUnfinished=returnUnfinished, no_watch=no_watch, json=json, called=called, greppable=greppable,
 					   unavailableHosts=unavailableHosts,willUpdateUnreachableHosts=willUpdateUnreachableHosts,
-					   curses_min_char_len = curses_min_char_len, curses_min_line_len = curses_min_line_len,
+					   window_width = window_width, window_height = window_height,
 					   single_window=single_window,unavailable_host_expiry=unavailable_host_expiry)
 			allHosts += hosts
 		return allHosts
@@ -2933,8 +3780,8 @@ def generate_default_config(args):
 		'DEFAULT_HOSTS': args.hosts,
 		'DEFAULT_USERNAME': args.username,
 		'DEFAULT_PASSWORD': args.password,
-		'DEFAULT_IDENTITY_FILE': args.key if args.key and not os.path.isdir(args.key) else DEFAULT_IDENTITY_FILE,
-		'DEDAULT_SSH_KEY_SEARCH_PATH': args.key if args.key and os.path.isdir(args.key) else DEDAULT_SSH_KEY_SEARCH_PATH,
+		'DEFAULT_IDENTITY_FILE': args.identity_file if args.identity_file and not os.path.isdir(args.identity_file) else DEFAULT_IDENTITY_FILE,
+		'DEFAULT_SSH_KEY_SEARCH_PATH': args.identity_file if args.identity_file and os.path.isdir(args.identity_file) else DEFAULT_SSH_KEY_SEARCH_PATH,
 		'DEFAULT_USE_KEY': args.use_key,
 		'DEFAULT_EXTRA_ARGS': args.extraargs,
 		'DEFAULT_ONE_ON_ONE': args.oneonone,
@@ -2948,15 +3795,17 @@ def generate_default_config(args):
 		'DEFAULT_IPMI': args.ipmi,
 		'DEFAULT_IPMI_INTERFACE_IP_PREFIX': args.ipmi_interface_ip_prefix,
 		'DEFAULT_INTERFACE_IP_PREFIX': args.interface_ip_prefix,
+		'DEFAULT_IPMI_USERNAME': args.ipmi_username,
+		'DEFAULT_IPMI_PASSWORD': args.ipmi_password,
 		'DEFAULT_NO_WATCH': args.no_watch,
-		'DEFAULT_CURSES_MINIMUM_CHAR_LEN': args.window_width,
-		'DEFAULT_CURSES_MINIMUM_LINE_LEN': args.window_height,
+		'DEFAULT_WINDOW_WIDTH': args.window_width,
+		'DEFAULT_WINDOW_HEIGHT': args.window_height,
 		'DEFAULT_SINGLE_WINDOW': args.single_window,
 		'DEFAULT_ERROR_ONLY': args.error_only,
 		'DEFAULT_NO_OUTPUT': args.no_output,
 		'DEFAULT_RETURN_ZERO': args.return_zero,
 		'DEFAULT_NO_ENV': args.no_env,
-		'DEFAULT_ENV_FILE': args.env_file,
+		'DEFAULT_ENV_FILES': args.env_files,
 		'DEFAULT_NO_HISTORY': args.no_history,
 		'DEFAULT_HISTORY_FILE': args.history_file,
 		'DEFAULT_MAX_CONNECTIONS': args.max_connections if args.max_connections != 4 * os.cpu_count() else None,
@@ -2966,8 +3815,10 @@ def generate_default_config(args):
 		'DEFAULT_SKIP_UNREACHABLE': args.skip_unreachable,
 		'DEFAULT_SKIP_HOSTS': args.skip_hosts,
 		'DEFAULT_ENCODING': args.encoding,
+		'DEFAULT_DIFF_DISPLAY_THRESHOLD': args.diff_display_threshold,
 		'SSH_STRICT_HOST_KEY_CHECKING': SSH_STRICT_HOST_KEY_CHECKING,
 		'ERROR_MESSAGES_TO_IGNORE': ERROR_MESSAGES_TO_IGNORE,
+		'FORCE_TRUECOLOR': args.force_truecolor,
 	}
 
 def write_default_config(args,CONFIG_FILE = None):
@@ -2980,9 +3831,9 @@ def write_default_config(args,CONFIG_FILE = None):
 	backup = True
 	if os.path.exists(CONFIG_FILE):
 		eprint(f"Warning: {CONFIG_FILE!r} already exists, what to do? (o/b/n)")
-		eprint(f"o:  Overwrite the file")
+		eprint("o:  Overwrite the file")
 		eprint(f"b:  Rename the current config file at {CONFIG_FILE!r}.bak forcefully and write the new config file (default)")
-		eprint(f"n:  Do nothing")
+		eprint("n:  Do nothing")
 		inStr = input_with_timeout_and_countdown(10)
 		if (not inStr) or inStr.lower().strip().startswith('b'):
 			backup = True
@@ -3005,26 +3856,26 @@ def write_default_config(args,CONFIG_FILE = None):
 		eprint(f"Config file written to {CONFIG_FILE!r}")
 	except Exception as e:
 		eprint(f"Error: Unable to write to the config file: {e!r}")
-		eprint(f'Printing the config file to stdout:')
+		eprint('Printing the config file to stdout:')
 		print(json.dumps(__configs_from_file, indent=4))
 
 #%% ------------ Argument Processing -----------------
 def get_parser():
 	global _binPaths
-	parser = argparse.ArgumentParser(description=f'Run a command on multiple hosts, Use #HOST# or #HOSTNAME# to replace the host name in the command. Config file chain: {CONFIG_FILE_CHAIN!r}',
-								  epilog=f'Found bins: {list(_binPaths.values())}\n Missing bins: {_binCalled - set(_binPaths.keys())}')
+	parser = argparse.ArgumentParser(description='Run a command on multiple hosts, Use #HOST# or #HOSTNAME# to replace the host name in the command.',
+								  epilog=f'Found bins: {list(_binPaths.values())}\n Missing bins: {_binCalled - set(_binPaths.keys())}\n Terminal color capability: {get_terminal_color_capability()}\nConfig file chain: {CONFIG_FILE_CHAIN!r}',)
 	parser.add_argument('hosts', metavar='hosts', type=str, nargs='?', help=f'Hosts to run the command on, use "," to seperate hosts. (default: {DEFAULT_HOSTS})',default=DEFAULT_HOSTS)
 	parser.add_argument('commands', metavar='commands', type=str, nargs='*',default=None,help='the command to run on the hosts / the destination of the files #HOST# or #HOSTNAME# will be replaced with the host name.')
 	parser.add_argument('-u','--username', type=str,help=f'The general username to use to connect to the hosts. Will get overwrote by individual username@host if specified. (default: {DEFAULT_USERNAME})',default=DEFAULT_USERNAME)
 	parser.add_argument('-p', '--password', type=str,help=f'The password to use to connect to the hosts, (default: {DEFAULT_PASSWORD})',default=DEFAULT_PASSWORD)
-	parser.add_argument('-k','--key','--identity',nargs='?', type=str,help=f'The identity file to use to connect to the hosts. Implies --use_key. Specify a folder for program to search for a key. Use option without value to use {DEDAULT_SSH_KEY_SEARCH_PATH} (default: {DEFAULT_IDENTITY_FILE})',const=DEDAULT_SSH_KEY_SEARCH_PATH,default=DEFAULT_IDENTITY_FILE)
+	parser.add_argument('-k','--identity_file','--key','--identity',nargs='?', type=str,help=f'The identity file to use to connect to the hosts. Implies --use_key. Specify a folder for program to search for a key. Use option without value to use {DEFAULT_SSH_KEY_SEARCH_PATH} (default: {DEFAULT_IDENTITY_FILE})',const=DEFAULT_SSH_KEY_SEARCH_PATH,default=DEFAULT_IDENTITY_FILE)
 	parser.add_argument('-uk','--use_key', action='store_true', help=f'Attempt to use public key file to connect to the hosts. (default: {DEFAULT_USE_KEY})', default=DEFAULT_USE_KEY)
 	parser.add_argument('-ea','--extraargs',type=str,help=f'Extra arguments to pass to the ssh / rsync / scp command. Put in one string for multiple arguments.Use "=" ! Ex. -ea="--delete" (default: {DEFAULT_EXTRA_ARGS})',default=DEFAULT_EXTRA_ARGS)
 	parser.add_argument("-11",'--oneonone', action='store_true', help=f"Run one corresponding command on each host. (default: {DEFAULT_ONE_ON_ONE})", default=DEFAULT_ONE_ON_ONE)
 	parser.add_argument("-f","--file", action='append', help="The file to be copied to the hosts. Use -f multiple times to copy multiple files")
-	parser.add_argument('-s','-fs','--file_sync', action='store_true', help=f'Operate in file sync mode, sync path in <COMMANDS> from this machine to <HOSTS>. Treat --file <FILE> and <COMMANDS> both as source and source and destination will be the same in this mode. Infer destination from source path. (default: {DEFAULT_FILE_SYNC})', default=DEFAULT_FILE_SYNC)
+	parser.add_argument('-s','-fs','--file_sync',nargs='?', action='append', help=f'Operate in file sync mode, sync path in <COMMANDS> from this machine to <HOSTS>. Treat --file <FILE> and <COMMANDS> both as source and source and destination will be the same in this mode. Infer destination from source path. (default: {DEFAULT_FILE_SYNC})',const=True, default=[DEFAULT_FILE_SYNC])
 	parser.add_argument('-W','--scp', action='store_true', help=f'Use scp for copying files instead of rsync. Need to use this on windows. (default: {DEFAULT_SCP})', default=DEFAULT_SCP)
-	parser.add_argument('-G','-gm','--gather_mode', action='store_true', help=f'Gather files from the hosts instead of sending files to the hosts. Will send remote files specified in <FILE> to local path specified in <COMMANDS>  (default: False)', default=False)
+	parser.add_argument('-G','-gm','--gather_mode', action='store_true', help='Gather files from the hosts instead of sending files to the hosts. Will send remote files specified in <FILE> to local path specified in <COMMANDS>  (default: False)', default=False)
 	#parser.add_argument("-d",'-c',"--destination", type=str, help="The destination of the files. Same as specify with commands. Added for compatibility. Use #HOST# or #HOSTNAME# to replace the host name in the destination")
 	parser.add_argument("-t","--timeout", type=int, help=f"Timeout for each command in seconds. Set default value via DEFAULT_CLI_TIMEOUT in config file. Use 0 for disabling timeout. (default: {DEFAULT_CLI_TIMEOUT})", default=DEFAULT_CLI_TIMEOUT)
 	parser.add_argument('-T','--use_script_timeout',action='store_true', help=f'Use shortened timeout suitable to use in a script. Set value via DEFAULT_TIMEOUT field in config file. (current: {DEFAULT_TIMEOUT})', default=False)
@@ -3033,37 +3884,45 @@ def get_parser():
 	parser.add_argument('-M',"--ipmi", action='store_true', help=f"Use ipmitool to run the command. (default: {DEFAULT_IPMI})", default=DEFAULT_IPMI)
 	parser.add_argument("-mpre","--ipmi_interface_ip_prefix", type=str, help=f"The prefix of the IPMI interfaces (default: {DEFAULT_IPMI_INTERFACE_IP_PREFIX})", default=DEFAULT_IPMI_INTERFACE_IP_PREFIX)
 	parser.add_argument("-pre","--interface_ip_prefix", type=str, help=f"The prefix of the for the interfaces (default: {DEFAULT_INTERFACE_IP_PREFIX})", default=DEFAULT_INTERFACE_IP_PREFIX)
-	parser.add_argument('-S',"-q","-nw","--no_watch","--quiet", action='store_true', help=f"Quiet mode, no curses watch, only print the output. (default: {DEFAULT_NO_WATCH})", default=DEFAULT_NO_WATCH)
-	parser.add_argument("-ww",'--window_width', type=int, help=f"The minimum character length of the curses window. (default: {DEFAULT_CURSES_MINIMUM_CHAR_LEN})", default=DEFAULT_CURSES_MINIMUM_CHAR_LEN)
-	parser.add_argument("-wh",'--window_height', type=int, help=f"The minimum line height of the curses window. (default: {DEFAULT_CURSES_MINIMUM_LINE_LEN})", default=DEFAULT_CURSES_MINIMUM_LINE_LEN)
+	parser.add_argument('-iu','--ipmi_username', type=str,help=f'The username to use to connect to the hosts via ipmi. (default: {DEFAULT_IPMI_USERNAME})',default=DEFAULT_IPMI_USERNAME)
+	parser.add_argument('-ip','--ipmi_password', type=str,help=f'The password to use to connect to the hosts via ipmi. (default: {DEFAULT_IPMI_PASSWORD})',default=DEFAULT_IPMI_PASSWORD)
+	parser.add_argument('-S',"-q","-nw","--no_watch", action='store_true', help=f"Quiet mode, no curses watch, only print the output. (default: {DEFAULT_NO_WATCH})", default=DEFAULT_NO_WATCH)
+	parser.add_argument("-ww",'--window_width', type=int, help=f"The minimum character length of the curses window. (default: {DEFAULT_WINDOW_WIDTH})", default=DEFAULT_WINDOW_WIDTH)
+	parser.add_argument("-wh",'--window_height', type=int, help=f"The minimum line height of the curses window. (default: {DEFAULT_WINDOW_HEIGHT})", default=DEFAULT_WINDOW_HEIGHT)
 	parser.add_argument('-B','-sw','--single_window', action='store_true', help=f'Use a single window for all hosts. (default: {DEFAULT_SINGLE_WINDOW})', default=DEFAULT_SINGLE_WINDOW)
 	parser.add_argument('-R','-eo','--error_only', action='store_true', help=f'Only print the error output. (default: {DEFAULT_ERROR_ONLY})', default=DEFAULT_ERROR_ONLY)
-	parser.add_argument('-Q',"-no","--no_output", action='store_true', help=f"Do not print the output. (default: {DEFAULT_NO_OUTPUT})", default=DEFAULT_NO_OUTPUT)
+	parser.add_argument('-Q',"-no","--no_output","--quiet", action='store_true', help=f"Do not print the output. (default: {DEFAULT_NO_OUTPUT})", default=DEFAULT_NO_OUTPUT)
 	parser.add_argument('-Z','-rz','--return_zero', action='store_true', help=f"Return 0 even if there are errors. (default: {DEFAULT_RETURN_ZERO})", default=DEFAULT_RETURN_ZERO)
 	parser.add_argument('-C','--no_env', action='store_true', help=f'Do not load the command line environment variables. (default: {DEFAULT_NO_ENV})', default=DEFAULT_NO_ENV)
-	parser.add_argument("--env_file", type=str, help=f"The file to load the mssh file based environment variables from. ( Still work with --no_env ) (default: {DEFAULT_ENV_FILE})", default=DEFAULT_ENV_FILE)
-	parser.add_argument("-m","--max_connections", type=int, help=f"Max number of connections to use (default: 4 * cpu_count)", default=DEFAULT_MAX_CONNECTIONS)
+	parser.add_argument('-ef',"--env_file", type=str, help="Replace the env file look up chain with this env_file. ( Still work with --no_env ) (default: None)", default='')
+	parser.add_argument('-efs',"--env_files", action='append', help=f"The files to load the mssh file based environment variables from. Can specify multiple. Load first to last. ( Still work with --no_env ) (default: {DEFAULT_ENV_FILES})")
+	parser.add_argument("-m","--max_connections", type=int, help="Max number of connections to use (default: 4 * cpu_count)", default=DEFAULT_MAX_CONNECTIONS)
 	parser.add_argument("-j","--json", action='store_true', help=F"Output in json format. (default: {DEFAULT_JSON_MODE})", default=DEFAULT_JSON_MODE)
 	parser.add_argument('-w',"--success_hosts", action='store_true', help=f"Output the hosts that succeeded in summary as well. (default: {DEFAULT_PRINT_SUCCESS_HOSTS})", default=DEFAULT_PRINT_SUCCESS_HOSTS)
 	parser.add_argument('-P',"-g","--greppable",'--table', action='store_true', help=f"Output in greppable table. (default: {DEFAULT_GREPPABLE_MODE})", default=DEFAULT_GREPPABLE_MODE)
-	group = parser.add_mutually_exclusive_group()
-	group.add_argument('-x',"-su","--skip_unreachable", action='store_true', help=f"Skip unreachable hosts. Note: Timedout Hosts are considered unreachable. Note: multiple command sequence will still auto skip unreachable hosts. (default: {DEFAULT_SKIP_UNREACHABLE})", default=DEFAULT_SKIP_UNREACHABLE)
-	group.add_argument('-a',"-nsu","--no_skip_unreachable",dest = 'skip_unreachable', action='store_false', help=f"Do not skip unreachable hosts. Note: Timedout Hosts are considered unreachable. Note: multiple command sequence will still auto skip unreachable hosts. (default: {not DEFAULT_SKIP_UNREACHABLE})", default=not DEFAULT_SKIP_UNREACHABLE)
+	su_group = parser.add_mutually_exclusive_group()
+	su_group.add_argument('-x',"-su","--skip_unreachable", action='store_true', help=f"Skip unreachable hosts. Note: Timedout Hosts are considered unreachable. Note: multiple command sequence will still auto skip unreachable hosts. (default: {DEFAULT_SKIP_UNREACHABLE})", default=DEFAULT_SKIP_UNREACHABLE)
+	su_group.add_argument('-a',"-nsu","--no_skip_unreachable",dest = 'skip_unreachable', action='store_false', help=f"Do not skip unreachable hosts. Note: Timedout Hosts are considered unreachable. Note: multiple command sequence will still auto skip unreachable hosts. (default: {not DEFAULT_SKIP_UNREACHABLE})", default=not DEFAULT_SKIP_UNREACHABLE)
 	parser.add_argument('-uhe','--unavailable_host_expiry', type=int, help=f"Time in seconds to expire the unavailable hosts (default: {DEFAULT_UNAVAILABLE_HOST_EXPIRY})", default=DEFAULT_UNAVAILABLE_HOST_EXPIRY)
 	parser.add_argument('-X',"-sh","--skip_hosts", type=str, help=f"Skip the hosts in the list. (default: {DEFAULT_SKIP_HOSTS if DEFAULT_SKIP_HOSTS else 'None'})", default=DEFAULT_SKIP_HOSTS)
-	parser.add_argument('--generate_config_file', action='store_true', help=f'Store / generate the default config file from command line argument and current config at --config_file / stdout')
-	parser.add_argument('--config_file', type=str,nargs='?', help=f'Additional config file to use, will pioritize over config chains. When using with store_config_file, will store the resulting config file at this location. Use without a path will use multiSSH3.config.json',const='multiSSH3.config.json',default=None)
-	parser.add_argument('--store_config_file',type = str,nargs='?',help=f'Store the default config file from command line argument and current config. Same as --store_config_file --config_file=<path>',const='multiSSH3.config.json')
+	parser.add_argument('--generate_config_file', action='store_true', help='Store / generate the default config file from command line argument and current config at --config_file / stdout')
+	parser.add_argument('--config_file', type=str,nargs='?', help='Additional config file to use, will pioritize over config chains. When using with store_config_file, will store the resulting config file at this location. Use without a path will use multiSSH3.config.json',const='multiSSH3.config.json',default=None)
+	parser.add_argument('--store_config_file',type = str,nargs='?',help='Store the default config file from command line argument and current config. Same as --store_config_file --config_file=<path>',const='multiSSH3.config.json')
 	parser.add_argument('--debug', action='store_true', help='Print debug information')
 	parser.add_argument('-ci','--copy_id', action='store_true', help='Copy the ssh id to the hosts')
 	parser.add_argument('-I','-nh','--no_history', action='store_true', help=f'Do not record the command to history. Default: {DEFAULT_NO_HISTORY}', default=DEFAULT_NO_HISTORY)
 	parser.add_argument('-hf','--history_file', type=str, help=f'The file to store the history. (default: {DEFAULT_HISTORY_FILE})', default=DEFAULT_HISTORY_FILE)
 	parser.add_argument('--script', action='store_true', help='Run the command in script mode, short for -SCRIPT or --no_watch --skip_unreachable --no_env --no_history --greppable --error_only')
 	parser.add_argument('-e','--encoding', type=str, help=f'The encoding to use for the output. (default: {DEFAULT_ENCODING})', default=DEFAULT_ENCODING)
+	parser.add_argument('-dt','--diff_display_threshold', type=float, help=f'The threshold of lines to display the diff when files differ. {{0-1}} Set to 0 to always display the diff. Set to 1 to disable diff. (Only merge same) (default: {DEFAULT_DIFF_DISPLAY_THRESHOLD})', default=DEFAULT_DIFF_DISPLAY_THRESHOLD)
+	parser.add_argument('--force_truecolor', action='store_true', help=f'Force truecolor output even when not in a truecolor terminal. (default: {FORCE_TRUECOLOR})', default=FORCE_TRUECOLOR)
+	parser.add_argument('--add_control_master_config', action='store_true', help='Add ControlMaster configuration to ~/.ssh/config to speed up multiple connections to the same host.')
 	parser.add_argument("-V","--version", action='version', version=f'%(prog)s {version} @ {COMMIT_DATE} with [ {", ".join(_binPaths.keys())} ] by {AUTHOR} ({AUTHOR_EMAIL})')
 	return parser
 
 def process_args(args = None):
+	global DEFAULT_IPMI_USERNAME
+	global DEFAULT_IPMI_PASSWORD
 	parser = get_parser()
 	# We handle the signal
 	signal.signal(signal.SIGINT, signal_handler)
@@ -3087,7 +3946,18 @@ def process_args(args = None):
 		args.no_history = True
 		args.greppable = True
 		args.error_only = True
-
+	
+	if args.file_sync:
+		for path in args.file_sync:
+			if path and isinstance(path, str):
+				if args.file:
+					if path not in args.file:
+						args.file.append(path)
+				else:
+					args.file = [path]
+		args.file_sync = any(args.file_sync)
+	else:
+		args.file_sync = False
 	if args.unavailable_host_expiry <= 0:
 		eprint(f"Warning: The unavailable host expiry time {args.unavailable_host_expiry} is less than 0, setting it to 10 seconds.")
 		args.unavailable_host_expiry = 10
@@ -3106,7 +3976,7 @@ def process_config_file(args):
 		else:
 			configFileToWriteTo = args.config_file
 		write_default_config(args,configFileToWriteTo)
-		if not args.commands:
+		if not args.commands and not args.file:
 			if configFileToWriteTo:
 				with open(configFileToWriteTo,'r') as f:
 					eprint(f"Config file content: \n{f.read()}")
@@ -3123,10 +3993,10 @@ def process_config_file(args):
 
 def process_commands(args):
 	if not args.file and len(args.commands) > 1 and all([len(command.split()) == 1 for command in args.commands]):
-		eprint(f"Multiple one word command detected, what to do? (1/m/n)")
+		eprint("Multiple one word command detected, what to do? (1/m/n)")
 		eprint(f"1:  Run 1 command [{' '.join(args.commands)}] on all hosts ( default )")
 		eprint(f"m:  Run multiple commands [{', '.join(args.commands)}] on all hosts")
-		eprint(f"n:  Exit")
+		eprint("n:  Exit")
 		inStr = input_with_timeout_and_countdown(3)
 		if (not inStr) or inStr.lower().strip().startswith('1'):
 			args.commands = [" ".join(args.commands)]
@@ -3138,32 +4008,74 @@ def process_commands(args):
 	return args
 
 def process_keys(args):
-	if args.key or args.use_key:
-		if not args.key:
-			args.key = find_ssh_key_file()
+	if args.identity_file or args.use_key:
+		if not args.identity_file:
+			args.identity_file = find_ssh_key_file()
 		else:
-			if os.path.isdir(os.path.expanduser(args.key)):
-				args.key = find_ssh_key_file(args.key)
-			elif not os.path.exists(args.key):
-				eprint(f"Warning: Identity file {args.key!r} not found. Passing to ssh anyway. Proceed with caution.")
+			if os.path.isdir(os.path.expanduser(args.identity_file)):
+				args.identity_file = find_ssh_key_file(args.identity_file)
+			elif not os.path.exists(args.identity_file):
+				eprint(f"Warning: Identity file {args.identity_file!r} not found. Passing to ssh anyway. Proceed with caution.")
 	return args
 
+def process_control_master_config(args):
+	global __control_master_string
+	if args.add_control_master_config:
+		try:
+			if not os.path.exists(os.path.expanduser('~/.ssh')):
+				os.makedirs(os.path.expanduser('~/.ssh'),mode=0o700)
+			ssh_config_file = os.path.expanduser('~/.ssh/config')
+			if not os.path.exists(ssh_config_file):
+				with open(ssh_config_file,'w') as f:
+					f.write(__control_master_string)
+				os.chmod(ssh_config_file,0o644)
+			else:
+				with open(ssh_config_file,'r') as f:
+					ssh_config_content = f.readlines()
+				if set(map(str.strip,ssh_config_content)).issuperset(set(map(str.strip,__control_master_string.splitlines()))):
+					eprint("ControlMaster configuration already exists in ~/.ssh/config, skipping adding:")
+					eprint(__control_master_string)
+				else:
+					with open(ssh_config_file,'a') as f:
+						f.write('\n# Added by multiSSH3.py to speed up subsequent connections\n')
+						f.write(__control_master_string)
+					eprint("ControlMaster configuration added to ~/.ssh/config.")
+		except Exception as e:
+			eprint(f"Error adding ControlMaster configuration: {e}")
+			import traceback
+			traceback.print_exc()
+		if not args.commands and not args.file:
+			_exit_with_code(0, "Done configuring ControlMaster.")
+	return args
 
 def set_global_with_args(args):
 	global _emo
 	global __ipmiiInterfaceIPPrefix
-	global _env_file
+	global _env_files
 	global __DEBUG_MODE
 	global __configs_from_file
 	global _encoding
 	global __returnZero
+	global DEFAULT_IPMI_USERNAME
+	global DEFAULT_IPMI_PASSWORD
+	global DEFAULT_DIFF_DISPLAY_THRESHOLD
+	global FORCE_TRUECOLOR
 	_emo = False
 	__ipmiiInterfaceIPPrefix = args.ipmi_interface_ip_prefix
-	_env_file = args.env_file
+	if args.env_file:
+		_env_files = [args.env_file]
+	else:
+		_env_files = DEFAULT_ENV_FILES + args.env_files if args.env_files else DEFAULT_ENV_FILES
 	__DEBUG_MODE = args.debug
 	_encoding = args.encoding
 	if args.return_zero:
 		__returnZero = True
+	if args.ipmi_username:
+		DEFAULT_IPMI_USERNAME = args.ipmi_username
+	if args.ipmi_password:
+		DEFAULT_IPMI_PASSWORD = args.ipmi_password
+	DEFAULT_DIFF_DISPLAY_THRESHOLD = args.diff_display_threshold
+	FORCE_TRUECOLOR = args.force_truecolor
 
 #%% ------------ Wrapper Block ----------------
 def main():
@@ -3174,6 +4086,7 @@ def main():
 	args = process_config_file(args)
 	args = process_commands(args)
 	args = process_keys(args)
+	args = process_control_master_config(args)
 	set_global_with_args(args)
 	
 	if args.use_script_timeout:
@@ -3184,16 +4097,7 @@ def main():
 	if args.no_output:
 		__global_suppress_printout = True
 	if not __global_suppress_printout:
-		cmdStr = getStrCommand(args.hosts,args.commands,
-						 oneonone=args.oneonone,timeout=args.timeout,password=args.password,
-						 no_watch=args.no_watch,json=args.json,called=args.no_output,max_connections=args.max_connections,
-						 files=args.file,file_sync=args.file_sync,ipmi=args.ipmi,interface_ip_prefix=args.interface_ip_prefix,scp=args.scp,gather_mode = args.gather_mode,username=args.username,
-						 extraargs=args.extraargs,skipUnreachable=args.skip_unreachable,no_env=args.no_env,greppable=args.greppable,skip_hosts = args.skip_hosts,
-						 curses_min_char_len = args.window_width, curses_min_line_len = args.window_height,single_window=args.single_window,error_only=args.error_only,identity_file=args.key,
-						 copy_id=args.copy_id,unavailable_host_expiry=args.unavailable_host_expiry,no_history=args.no_history,
-						 history_file = args.history_file, 
-						 env_file = args.env_file,
-						 repeat = args.repeat,interval = args.interval)
+		cmdStr = getStrCommand(**vars(args))
 		eprint('> ' + cmdStr)
 	if args.error_only:
 		__global_suppress_printout = True
@@ -3203,16 +4107,9 @@ def main():
 			eprint(f"Sleeping for {args.interval} seconds")
 			time.sleep(args.interval)
 
-		if not __global_suppress_printout: eprint(f"Running the {i+1}/{args.repeat} time") if args.repeat > 1 else None
-		hosts = run_command_on_hosts(args.hosts,args.commands,
-							 oneonone=args.oneonone,timeout=args.timeout,password=args.password,
-							 no_watch=args.no_watch,json=args.json,called=args.no_output,max_connections=args.max_connections,
-							 files=args.file,file_sync=args.file_sync,ipmi=args.ipmi,interface_ip_prefix=args.interface_ip_prefix,scp=args.scp,gather_mode = args.gather_mode,username=args.username,
-							 extraargs=args.extraargs,skipUnreachable=args.skip_unreachable,no_env=args.no_env,greppable=args.greppable,skip_hosts = args.skip_hosts,
-							 curses_min_char_len = args.window_width, curses_min_line_len = args.window_height,single_window=args.single_window,error_only=args.error_only,identity_file=args.key,
-							 copy_id=args.copy_id,unavailable_host_expiry=args.unavailable_host_expiry,no_history=args.no_history,
-							 history_file = args.history_file,
-							 )
+		if not __global_suppress_printout: 
+			eprint(f"Running the {i+1}/{args.repeat} time") if args.repeat > 1 else None
+		hosts = run_command_on_hosts(**vars(args),called=False)
 		#print('*'*80)
 		#if not __global_suppress_printout: eprint('-'*80)
 	succeededHosts = set()
@@ -3227,12 +4124,13 @@ def main():
 	if __mainReturnCode > 0:
 		if not __global_suppress_printout: 
 			eprint(f'Complete. Failed hosts (Return Code not 0) count: {__mainReturnCode}')
-			eprint(f'failed_hosts: {",".join(sorted(compact_hostnames(__failedHosts)))}')
+			eprint(f'failed_hosts: {",".join(compact_hostnames(__failedHosts))}')
 	else:
-		if not __global_suppress_printout: eprint('Complete. All hosts returned 0.')
+		if not __global_suppress_printout: 
+			eprint('Complete. All hosts returned 0.')
 	
 	if args.success_hosts and not __global_suppress_printout:
-		eprint(f'succeeded_hosts: {",".join(sorted(compact_hostnames(succeededHosts)))}')
+		eprint(f'succeeded_hosts: {",".join(compact_hostnames(succeededHosts))}')
 
 	if threading.active_count() > 1 and not __global_suppress_printout: 
 		eprint(f'Remaining active thread: {threading.active_count()}')