secator 0.0.1__py3-none-any.whl → 0.3.6__py3-none-any.whl

secator/runners/_base.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import os
 import sys
 import uuid
 from contextlib import nullcontext
@@ -7,18 +8,17 @@ from datetime import datetime
 from time import sleep, time
 
 import humanize
-from celery.result import AsyncResult
 from dotmap import DotMap
 from rich.padding import Padding
 from rich.panel import Panel
 from rich.progress import Progress as RichProgress
 from rich.progress import SpinnerColumn, TextColumn, TimeElapsedColumn
 
-from secator.definitions import DEBUG, DEFAULT_PROGRESS_UPDATE_FREQUENCY
+from secator.definitions import DEBUG, DEFAULT_PROGRESS_UPDATE_FREQUENCY, REPORTS_FOLDER
 from secator.output_types import OUTPUT_TYPES, OutputType, Progress
 from secator.report import Report
 from secator.rich import console, console_stdout
-from secator.runners._helpers import (get_task_data, get_task_ids,
+from secator.runners._helpers import (get_task_data, get_task_ids, get_task_folder_id,
 									  process_extractor)
 from secator.utils import (debug, import_dynamic, merge_opts, pluralize,
 						   rich_to_ansi)
@@ -76,6 +76,9 @@ class Runner:
 	# Run hooks
 	enable_hooks = True
 
+	# Reports folder
+	reports_folder = None
+
 	def __init__(self, config, targets, results=[], run_opts={}, hooks={}, context={}):
 		self.config = config
 		self.name = run_opts.get('name', config.name)
@@ -103,7 +106,17 @@ class Runner:
 		self.context = context
 		self.delay = run_opts.get('delay', False)
 		self.uuids = []
-		self.result = None
+		self.celery_result = None
+
+		# Determine report folder
+		default_reports_folder_base = f'{REPORTS_FOLDER}/{self.workspace_name}/{self.config.type}s'
+		_id = get_task_folder_id(default_reports_folder_base)
+		self.reports_folder = f'{default_reports_folder_base}/{_id}'
+
+		# Make reports folders
+		os.makedirs(self.reports_folder, exist_ok=True)
+		os.makedirs(f'{self.reports_folder}/.inputs', exist_ok=True)
+		os.makedirs(f'{self.reports_folder}/.outputs', exist_ok=True)
 
 		# Process input
 		self.input = targets
@@ -122,7 +135,8 @@ class Runner:
 		# Print options
 		self.print_start = self.run_opts.pop('print_start', False)
 		self.print_item = self.run_opts.pop('print_item', False)
-		self.print_line = self.run_opts.pop('print_line', self.sync and not self.output_quiet)
+		self.print_line = self.run_opts.pop('print_line', False)
+		self.print_errors = self.run_opts.pop('print_errors', True)
 		self.print_item_count = self.run_opts.pop('print_item_count', False)
 		self.print_cmd = self.run_opts.pop('print_cmd', False)
 		self.print_run_opts = self.run_opts.pop('print_run_opts', DEBUG > 1)
@@ -139,12 +153,26 @@ class Runner:
 		self.opts_to_print = {k: v for k, v in self.__dict__.items() if k.startswith('print_') if v}
 
 		# Hooks
+		self.raise_on_error = self.run_opts.get('raise_on_error', False)
 		self.hooks = {name: [] for name in HOOKS}
 		for key in self.hooks:
-			instance_func = getattr(self, key, None)
-			if instance_func:
-				self.hooks[key].append(instance_func)
-			self.hooks[key].extend(hooks.get(self.__class__, {}).get(key, []))
+
+			# Register class specific hooks
+			class_hook = getattr(self, key, None)
+			if class_hook:
+				name = f'{self.__class__.__name__}.{key}'
+				fun = self.get_func_path(class_hook)
+				debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered'}, sub='hooks', level=3)
+				self.hooks[key].append(class_hook)
+
+			# Register user hooks
+			user_hooks = hooks.get(self.__class__, {}).get(key, [])
+			user_hooks.extend(hooks.get(key, []))
+			for hook in user_hooks:
+				name = f'{self.__class__.__name__}.{key}'
+				fun = self.get_func_path(hook)
+				debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered (user)'}, sub='hooks', level=3)
+			self.hooks[key].extend(user_hooks)
 
 		# Validators
 		self.validators = {name: [] for name in VALIDATORS}
@@ -159,6 +187,8 @@ class Runner:
 		self.has_children = self.run_opts.get('has_children', False)
 		self.chunk = self.run_opts.get('chunk', None)
 		self.chunk_count = self.run_opts.get('chunk_count', None)
+		self.unique_name = self.name.replace('/', '_')
+		self.unique_name = f'{self.unique_name}_{self.chunk}' if self.chunk else self.unique_name
 		self._set_print_prefix()
 
 		# Input post-process
@@ -234,7 +264,7 @@ class Runner:
 
 				elif item and isinstance(item, str):
 					if self.print_line:
-						self._print(item, out=sys.stderr)
+						self._print(item, out=sys.stderr, end='\n')
 					if not self.output_json:
 						self.results.append(item)
 						yield item
@@ -249,9 +279,9 @@ class Runner:
 
 		except KeyboardInterrupt:
 			self._print('Process was killed manually (CTRL+C / CTRL+X).', color='bold red', rich=True)
-			if self.result:
+			if self.celery_result:
 				self._print('Revoking remote Celery tasks ...', color='bold red', rich=True)
-				self.stop_live_tasks(self.result)
+				self.stop_live_tasks(self.celery_result)
 
 		# Filter results and log info
 		self.mark_duplicates()
@@ -260,9 +290,10 @@ class Runner:
 		self.run_hooks('on_end')
 
 	def mark_duplicates(self):
-		debug('duplicate check', id=self.config.name, sub='runner.mark_duplicates')
+		debug('running duplicate check', id=self.config.name, sub='runner.mark_duplicates')
+		dupe_count = 0
 		for item in self.results:
-			debug('duplicate check', obj=item.toDict(), obj_breaklines=True, sub='runner.mark_duplicates', level=2)
+			debug('running duplicate check', obj=item.toDict(), obj_breaklines=True, sub='runner.mark_duplicates', level=5)
 			others = [f for f in self.results if f == item and f._uuid != item._uuid]
 			if others:
 				main = max(item, *others)
@@ -282,13 +313,16 @@ class Runner:
 					if not dupe._duplicate:
 						debug(
 							'found new duplicate', obj=dupe.toDict(), obj_breaklines=True,
-							sub='runner.mark_duplicates', level=2)
+							sub='runner.mark_duplicates', level=5)
+						dupe_count += 1
 						dupe._duplicate = True
 						dupe = self.run_hooks('on_duplicate', dupe)
 
-		debug('Duplicates:', sub='runner.mark_duplicates', level=2)
-		debug('\n\t'.join([repr(i) for i in self.results if i._duplicate]), sub='runner.mark_duplicates', level=2)
-		debug('duplicate check completed', id=self.config.name, sub='runner.mark_duplicates')
+		duplicates = [repr(i) for i in self.results if i._duplicate]
+		if duplicates:
+			duplicates_str = '\n\t'.join(duplicates)
+			debug(f'Duplicates ({dupe_count}):\n\t{duplicates_str}', sub='runner.mark_duplicates', level=5)
+		debug(f'duplicate check completed: {dupe_count} found', id=self.config.name, sub='runner.mark_duplicates')
 
 	def yielder(self):
 		raise NotImplementedError()
@@ -325,17 +359,24 @@ class Runner:
 			return result
 		for hook in self.hooks[hook_type]:
 			name = f'{self.__class__.__name__}.{hook_type}'
-			fun = f'{hook.__module__}.{hook.__name__}'
+			fun = self.get_func_path(hook)
 			try:
 				_id = self.context.get('task_id', '') or self.context.get('workflow_id', '') or self.context.get('scan_id', '')
 				debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'started'}, id=_id, sub='hooks', level=3)
 				result = hook(self, *args)
+				debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'ended'}, id=_id, sub='hooks', level=3)
 			except Exception as e:
-				self._print(f'{fun} failed: "{e.__class__.__name__}". Skipping', color='bold red', rich=True)
-				if DEBUG > 1:
-					logger.exception(e)
+				if self.raise_on_error:
+					raise e
 				else:
-					self._print('Please set DEBUG to > 1 to see the detailed exception.', color='dim red', rich=True)
+					if DEBUG > 1:
+						logger.exception(e)
+					else:
+						self._print(
+							f'{fun} failed: "{e.__class__.__name__}: {str(e)}". Skipping',
+							color='bold red',
+							rich=True)
+						self._print('Set DEBUG to > 1 to see the detailed exception.', color='dim red', rich=True)
 		return result
 
 	def run_validators(self, validator_type, *args):
@@ -444,15 +485,15 @@ class Runner:
 		# Log runner infos
 		if self.infos:
 			self._print(
-				f'✓  [bold magenta]{self.config.name}[/] infos ({len(self.infos)}):',
+				f':heavy_check_mark: [bold magenta]{self.config.name}[/] infos ({len(self.infos)}):',
 				color='bold green', rich=True)
 			for info in self.infos:
 				self._print(f'   • {info}', color='bold green', rich=True)
 
 		# Log runner errors
-		if self.errors:
+		if self.errors and self.print_errors:
 			self._print(
-				f'❌ [bold magenta]{self.config.name}[/] errors ({len(self.errors)}):',
+				f':exclamation_mark:[bold magenta]{self.config.name}[/] errors ({len(self.errors)}):',
 				color='bold red', rich=True)
 			for error in self.errors:
 				self._print(f'   • {error}', color='bold red', rich=True)
@@ -468,9 +509,9 @@ class Runner:
 		if self.print_item_count and not self.print_raw and not self.orig:
 			count_map = self._get_results_count()
 			if all(count == 0 for count in count_map.values()):
-				self._print(':adhesive_bandage: Found 0 results.', color='bold red', rich=True)
+				self._print(':exclamation_mark:Found 0 results.', color='bold red', rich=True)
 			else:
-				results_str = ':pill: Found ' + ' and '.join([
+				results_str = ':heavy_check_mark: Found ' + ' and '.join([
 					f'{count} {pluralize(name) if count > 1 or count == 0 else name}'
 					for name, count in count_map.items()
 				]) + '.'
@@ -486,6 +527,7 @@ class Runner:
 		Yields:
 			dict: Subtasks state and results.
 		"""
+		from celery.result import AsyncResult
 		res = AsyncResult(result.id)
 		while True:
 			# Yield results
@@ -625,7 +667,6 @@ class Runner:
 				# 	continue
 
 				# Handle messages if any
-				# TODO: error handling should be moved to process_live_tasks
 				state = data['state']
 				error = data.get('error')
 				info = data.get('info')
@@ -711,7 +752,7 @@ class Runner:
 				break  # found an item that fits
 			except (TypeError, KeyError) as e:  # can't load using class
 				debug(
-					f'[dim red]Failed loading item as {klass.__name__}: {str(e)}.[/] [dim green]Continuing.[/]',
+					f'[dim red]Failed loading item as {klass.__name__}: {type(e).__name__}: {str(e)}.[/] [dim green]Continuing.[/]',
 					sub='klass.load',
 					level=5)
 				if DEBUG == 6:
@@ -725,12 +766,12 @@ class Runner:
 
 		return new_item
 
-	def _print(self, data, color=None, out=sys.stderr, rich=False):
+	def _print(self, data, color=None, out=sys.stderr, rich=False, end='\n'):
 		"""Print function.
 
 		Args:
 			data (str or dict): Input data.
-			color (str, Optional): Termcolor color.
+			color (str, Optional): Rich color.
 			out (str, Optional): Output pipe (sys.stderr, sys.stdout, ...)
 			rich (bool, Optional): Force rich output.
 		"""
@@ -743,7 +784,7 @@ class Runner:
 
 		if self.sync or rich:
 			_console = console_stdout if out == sys.stdout else console
-			_console.print(data, highlight=False, style=color, soft_wrap=True)
+			_console.print(data, highlight=False, style=color, soft_wrap=True, end=end)
 		else:
 			print(data, file=out)
 
@@ -807,10 +848,12 @@ class Runner:
 		if not item._uuid:
 			item._uuid = str(uuid.uuid4())
 
-		if item._type == 'progress' and item._source == self.config.name and int(item.percent) != 100:
+		if item._type == 'progress' and item._source == self.config.name:
 			self.progress = item.percent
 			if self.last_updated_progress and (item._timestamp - self.last_updated_progress) < DEFAULT_PROGRESS_UPDATE_FREQUENCY:
 				return None
+			elif int(item.percent) in [0, 100]:
+				return None
 			else:
 				self.last_updated_progress = item._timestamp
 
@@ -831,3 +874,31 @@ class Runner:
 		elif isinstance(item, OutputType):
 			item = repr(item)
 		return item
+
+	@classmethod
+	def get_func_path(cls, func):
+		"""
+		Get the full symbolic path of a function or method, including staticmethods,
+		using function and method attributes.
+
+		Args:
+			func (function, method, or staticmethod): A function or method object.
+		"""
+		if hasattr(func, '__self__'):
+			if func.__self__ is not None:
+				# It's a method bound to an instance
+				class_name = func.__self__.__class__.__name__
+				return f"{func.__module__}.{class_name}.{func.__name__}"
+			else:
+				# It's a method bound to a class (class method)
+				class_name = func.__qualname__.rsplit('.', 1)[0]
+				return f"{func.__module__}.{class_name}.{func.__name__}"
+		else:
+			# Handle static and regular functions
+			if '.' in func.__qualname__:
+				# Static method or a function defined inside a class
+				class_name, func_name = func.__qualname__.rsplit('.', 1)
+				return f"{func.__module__}.{class_name}.{func_name}"
+			else:
+				# Regular function not attached to a class
+				return f"{func.__module__}.{func.__name__}"

secator/runners/_helpers.py

@@ -1,5 +1,4 @@
-from celery.result import AsyncResult, GroupResult
-from rich.prompt import Confirm
+import os
 
 from secator.utils import deduplicate
 
@@ -77,6 +76,7 @@ def get_task_ids(result, ids=[]):
 		result (Union[AsyncResult, GroupResult]): Celery result object.
 		ids (list): List of ids.
 	"""
+	from celery.result import AsyncResult, GroupResult
 	if result is None:
 		return
 
@@ -105,6 +105,7 @@ def get_task_data(task_id):
 	Returns:
 		dict: Task info (id, name, state, results, chunk_info, count, error, ready).
 	"""
+	from celery.result import AsyncResult
 	res = AsyncResult(task_id)
 	if not (res and res.args and len(res.args) > 1):
 		return
@@ -136,18 +137,18 @@ def get_task_data(task_id):
 	return data
 
 
-def confirm_exit(func):
-	"""Decorator asking user for confirmation to exit.
-
-	Args:
-		func (func): Decorated function.
-	"""
-	def inner_function(self, *args, **kwargs):
-		try:
-			func(self, *args, **kwargs)
-		except KeyboardInterrupt:
-			exit_confirmed = Confirm.ask('Are you sure you want to exit ?')
-			if exit_confirmed:
-				self.log_results()
-				raise KeyboardInterrupt
-	return inner_function
+def get_task_folder_id(path):
+	names = []
+	if not os.path.exists(path):
+		return 0
+	for f in os.scandir(path):
+		if f.is_dir():
+			try:
+				int(f.name)
+				names.append(int(f.name))
+			except ValueError:
+				continue
+	names.sort()
+	if names:
+		return names[-1] + 1
+	return 0

secator/runners/command.py

@@ -1,3 +1,4 @@
+import getpass
 import logging
 import os
 import re
@@ -7,19 +8,17 @@ import sys
 
 from time import sleep
 
-from celery.result import AsyncResult
 from fp.fp import FreeProxy
 
 from secator.config import ConfigLoader
-from secator.definitions import (DEBUG, DEFAULT_HTTP_PROXY,
+from secator.definitions import (DEFAULT_HTTP_PROXY,
 							   DEFAULT_FREEPROXY_TIMEOUT,
 							   DEFAULT_PROXYCHAINS_COMMAND,
 							   DEFAULT_SOCKS5_PROXY, OPT_NOT_SUPPORTED,
-							   OPT_PIPE_INPUT, DATA_FOLDER, DEFAULT_INPUT_CHUNK_SIZE)
-from secator.rich import console
+							   OPT_PIPE_INPUT, DEFAULT_INPUT_CHUNK_SIZE)
 from secator.runners import Runner
 from secator.serializers import JSONSerializer
-from secator.utils import get_file_timestamp, debug
+from secator.utils import debug
 
 # from rich.markup import escape
 # from rich.text import Text
@@ -78,8 +77,12 @@ class Command(Runner):
 	# Flag to enable output JSON
 	json_flag = None
 
-	# Install command
+	# Flag to show version
+	version_flag = None
+
+	# Install
 	install_cmd = None
+	install_github_handle = None
 
 	# Serializer
 	item_loader = None
@@ -97,9 +100,6 @@ class Command(Runner):
 	# Output
 	output = ''
 
-	# Default run opts
-	default_run_opts = {}
-
 	# Proxy options
 	proxychains = False
 	proxy_socks5 = False
@@ -134,6 +134,9 @@ class Command(Runner):
 		# No capturing of stdout / stderr.
 		self.no_capture = self.run_opts.get('no_capture', False)
 
+		# No processing of output lines.
+		self.no_process = self.run_opts.get('no_process', False)
+
 		# Proxy config (global)
 		self.proxy = self.run_opts.pop('proxy', False)
 		self.configure_proxy()
@@ -155,7 +158,7 @@ class Command(Runner):
 		if self.print_cmd and not self.has_children:
 			if self.sync and self.description:
 				self._print(f'\n:wrench: {self.description} ...', color='bold gold3', rich=True)
-			self._print(self.cmd, color='bold cyan', rich=True)
+			self._print(self.cmd.replace('[', '\\['), color='bold cyan', rich=True)
 
 		# Print built input
 		if self.print_input_file and self.input_path:
@@ -214,16 +217,6 @@ class Command(Runner):
 		from secator.celery import run_command
 		return run_command.si(results, cls.__name__, *args, opts=kwargs).set(queue=cls.profile)
 
-	@classmethod
-	def poll(cls, result):
-		# TODO: Move this to TaskBase
-		while not result.ready():
-			data = AsyncResult(result.id).info
-			if DEBUG > 1 and isinstance(data, dict):
-				print(data)
-			sleep(1)
-		return result.get()
-
 	def get_opt_value(self, opt_name):
 		return Command._get_opt_value(
 			self.run_opts,
@@ -260,35 +253,30 @@ class Command(Runner):
 	#---------------#
 
 	@classmethod
-	def install(cls):
-		"""Install command by running the content of cls.install_cmd."""
-		console.log(f':pill: Installing {cls.__name__}...', style='bold yellow')
-		if not cls.install_cmd:
-			console.log(f'{cls.__name__} install is not supported yet. Please install it manually.', style='bold red')
-			return
-		ret = cls.run_command(
-			cls.install_cmd,
-			name=cls.__name__,
-			print_cmd=True,
-			print_line=True,
-			cls_attributes={'shell': True}
-		)
-		if ret.return_code != 0:
-			console.log(f'Failed to install {cls.__name__}.', style='bold red')
-		else:
-			console.log(f'{cls.__name__} installed successfully !', style='bold green')
-		return ret
+	def execute(cls, cmd, name=None, cls_attributes={}, **kwargs):
+		"""Execute an ad-hoc command.
 
-	@classmethod
-	def run_command(cls, cmd, name='helperClass', cls_attributes={}, **kwargs):
-		"""Run adhoc command. Can be used without defining an inherited class to run a command, while still enjoying
-		all the good stuff in this class.
+		Can be used without defining an inherited class to run a command, while still enjoying all the good stuff in
+		this class.
+
+		Args:
+			cls (object): Class.
+			cmd (str): Command.
+			name (str): Printed name.
+			cls_attributes (dict): Class attributes.
+			kwargs (dict): Options.
+
+		Returns:
+			secator.runners.Command: instance of the Command.
 		"""
+		name = name or cmd.split(' ')[0]
+		kwargs['no_process'] = True
+		kwargs['print_cmd'] = not kwargs.get('quiet', False)
+		kwargs['print_item'] = not kwargs.get('quiet', False)
+		kwargs['print_line'] = not kwargs.get('quiet', False)
 		cmd_instance = type(name, (Command,), {'cmd': cmd})(**kwargs)
 		for k, v in cls_attributes.items():
 			setattr(cmd_instance, k, v)
-		cmd_instance.print_line = not kwargs.get('quiet', False)
-		cmd_instance.print_item = not kwargs.get('quiet', False)
 		cmd_instance.run()
 		return cmd_instance
 
@@ -352,6 +340,9 @@ class Command(Runner):
 		# Callback before running command
 		self.run_hooks('on_start')
 
+		# Check for sudo requirements and prepare the password if needed
+		sudo_password = self._prompt_sudo(self.cmd)
+
 		# Prepare cmds
 		command = self.cmd if self.shell else shlex.split(self.cmd)
 
@@ -365,6 +356,7 @@ class Command(Runner):
 			env.update(self.env)
 			process = subprocess.Popen(
 				command,
+				stdin=subprocess.PIPE if sudo_password else None,
 				stdout=sys.stdout if self.no_capture else subprocess.PIPE,
 				stderr=sys.stderr if self.no_capture else subprocess.STDOUT,
 				universal_newlines=True,
@@ -372,11 +364,16 @@ class Command(Runner):
 				env=env,
 				cwd=self.cwd)
 
+			# If sudo password is provided, send it to stdin
+			if sudo_password:
+				process.stdin.write(f"{sudo_password}\n")
+				process.stdin.flush()
+
 		except FileNotFoundError as e:
 			if self.config.name in str(e):
 				error = 'Executable not found.'
 				if self.install_cmd:
-					error += f' Install it with `secator utils install {self.config.name}`.'
+					error += f' Install it with `secator install tools {self.config.name}`.'
 			else:
 				error = str(e)
 			celery_id = self.context.get('celery_id', '')
@@ -384,8 +381,6 @@ class Command(Runner):
 				error += f' [{celery_id}]'
 			self.errors.append(error)
 			self.return_code = 1
-			if error:
-				self._print(error, color='bold red')
 			return
 
 		try:
@@ -400,8 +395,11 @@ class Command(Runner):
 				if not line:
 					break
 
-				# Strip line
-				line = line.strip()
+				# Strip line endings
+				line = line.rstrip()
+				if self.no_process:
+					yield line
+					continue
 
 				# Some commands output ANSI text, so we need to remove those ANSI chars
 				if self.encoding == 'ansi':
@@ -420,7 +418,7 @@ class Command(Runner):
 					items = self.run_item_loaders(line)
 
 				# Yield line if no items parsed
-				if not items and not self.output_quiet:
+				if not items:
 					yield line
 
 				# Turn results into list if not already a list
@@ -453,6 +451,48 @@ class Command(Runner):
 				items.extend(result)
 		return items
 
+	def _prompt_sudo(self, command):
+		"""
+		Checks if the command requires sudo and prompts for the password if necessary.
+
+		Args:
+			command (str): The initial command to be executed.
+
+		Returns:
+			str or None: The sudo password if required; otherwise, None.
+		"""
+		sudo_password = None
+
+		# Check if sudo is required by the command
+		if not re.search(r'\bsudo\b', command):
+			return None
+
+		# Check if sudo can be executed without a password
+		if subprocess.run(['sudo', '-n', 'true'], capture_output=True).returncode == 0:
+			return None
+
+		# Check if we have a tty
+		if not os.isatty(sys.stdin.fileno()):
+			self._print("No TTY detected. Sudo password prompt requires a TTY to proceed.", color='bold red')
+			sys.exit(1)
+
+		# If not, prompt the user for a password
+		self._print('[bold red]Please enter sudo password to continue.[/]')
+		for _ in range(3):
+			self._print('\[sudo] password: ')
+			sudo_password = getpass.getpass()
+			result = subprocess.run(
+				['sudo', '-S', '-p', '', 'true'],
+				input=sudo_password + "\n",
+				text=True,
+				capture_output=True
+			)
+			if result.returncode == 0:
+				return sudo_password  # Password is correct
+			self._print("Sorry, try again.")
+		self._print("Sudo password verification failed after 3 attempts.")
+		return None
+
 	def _wait_for_end(self, process):
 		"""Wait for process to finish and process output and return code."""
 		process.wait()
@@ -469,11 +509,9 @@ class Command(Runner):
 
 		if self.return_code == -2 or self.killed:
 			error = 'Process was killed manually (CTRL+C / CTRL+X)'
-			self._print(error, color='bold red')
 			self.errors.append(error)
 		elif self.return_code != 0:
 			error = f'Command failed with return code {self.return_code}.'
-			self._print(error, color='bold red')
 			self.errors.append(error)
 
 	@staticmethod
@@ -603,9 +641,7 @@ class Command(Runner):
 		# If input is a list and the tool has input_flag set to OPT_PIPE_INPUT, use cat-piped input.
 		# Otherwise pass the file path to the tool.
 		if isinstance(input, list):
-			timestr = get_file_timestamp()
-			cmd_name = cmd.split(' ')[0].split('/')[-1]
-			fpath = f'{DATA_FOLDER}/{cmd_name}_{timestr}.txt'
+			fpath = f'{self.reports_folder}/.inputs/{self.unique_name}.txt'
 
 			# Write the input to a file
 			with open(fpath, 'w') as f:

secator/runners/scan.py

@@ -42,13 +42,14 @@ class Scan(Runner):
 				console.log(f'No targets were specified for workflow {name}. Skipping.')
 				continue
 
-			# Workflow fmt options
+			# Workflow opts
 			run_opts = self.run_opts.copy()
 			fmt_opts = {
 				'json': run_opts.get('json', False),
 				'print_item': False,
 				'print_start': True,
 				'print_run_summary': True,
+				'print_progress': self.sync
 			}
 			run_opts.update(fmt_opts)
 

secator/runners/task.py

@@ -24,7 +24,7 @@ class Task(Runner):
 		# Get task class
 		task_cls = Task.get_task_class(self.config.name)
 
-		# Task opts
+		# Run opts
 		run_opts = self.run_opts.copy()
 		run_opts.pop('output', None)
 		dry_run = run_opts.get('show', False)
@@ -39,7 +39,8 @@ class Task(Runner):
 			'print_input_file': DEBUG > 0,
 			'print_item': True,
 			'print_item_count': not self.sync and not dry_run,
-			'print_line': not self.output_quiet,
+			'print_line': True
+			# 'print_line': self.sync and not self.output_quiet,
 		}
 		# self.print_item = not self.sync  # enable print_item for base Task only if running remote
 		run_opts.update(fmt_opts)
@@ -58,9 +59,9 @@ class Task(Runner):
 			if dry_run:  # don't run
 				return
 		else:
-			result = task_cls.delay(self.targets, **run_opts)
+			self.celery_result = task_cls.delay(self.targets, **run_opts)
 			task = self.process_live_tasks(
-				result,
+				self.celery_result,
 				description=False,
 				results_only=True,
 				print_remote_status=self.print_remote_status)