secator 0.15.1__py3-none-any.whl → 0.16.0__py3-none-any.whl

secator/installer.py

@@ -24,6 +24,7 @@ from secator.definitions import OPT_NOT_SUPPORTED
 from secator.output_types import Info, Warning, Error
 from secator.rich import console
 from secator.runners import Command
+from secator.utils import get_versions_from_string
 
 
 class InstallerStatus(Enum):
@@ -72,7 +73,7 @@ class ToolInstaller:
 
 		# Check PATH
 		path_var = os.environ.get('PATH', '')
-		if not str(CONFIG.dirs.bin) in path_var:
+		if str(CONFIG.dirs.bin) not in path_var:
 			console.print(Warning(message=f'Bin directory {CONFIG.dirs.bin} not found in PATH ! Binaries installed by secator will not work'))  # noqa: E501
 			console.print(Warning(message=f'Run "export PATH=$PATH:{CONFIG.dirs.bin}" to add the binaries to your PATH'))
 
@@ -90,11 +91,14 @@ class ToolInstaller:
 			status = gh_status
 
 		# Install from source
-		if tool_cls.install_cmd and not gh_status.is_ok():
-			status = SourceInstaller.install(tool_cls.install_cmd, tool_cls.install_version)
-			if not status.is_ok():
-				cls.print_status(status, name)
-				return status
+		if not gh_status.is_ok():
+			if not tool_cls.install_cmd:
+				status = InstallerStatus.INSTALL_SKIPPED_OK
+			else:
+				status = SourceInstaller.install(tool_cls.install_cmd, tool_cls.install_version)
+				if not status.is_ok():
+					cls.print_status(status, name)
+					return status
 
 		# Install post commands
 		if tool_cls.install_post:
@@ -215,6 +219,9 @@ class SourceInstaller:
 		if '[install_version]' in install_cmd:
 			version = version or 'latest'
 			install_cmd = install_cmd.replace('[install_version]', version)
+		elif '[install_version_strip]' in install_cmd:
+			version = version or 'latest'
+			install_cmd = install_cmd.replace('[install_version_strip]', version.lstrip('v'))
 
 		# Run command
 		ret = Command.execute(install_cmd, cls_attributes={'shell': True}, quiet=False)
@@ -243,7 +250,7 @@ class GithubInstaller:
 		system, arch, os_identifiers, arch_identifiers = cls._get_platform_identifier()
 		download_url = cls._find_matching_asset(release['assets'], os_identifiers, arch_identifiers)
 		if not download_url:
-			console.print(Error(message=f'Could not find a GitHub release matching distribution (system: {system}, arch: {arch}).'))  # noqa: E501
+			console.print(Warning(message=f'Could not find a GitHub release matching distribution (system: {system}, arch: {arch}).'))  # noqa: E501
 			return InstallerStatus.GITHUB_RELEASE_UNMATCHED_DISTRIBUTION
 
 		# Download and unpack asset
@@ -415,14 +422,11 @@ def get_version(version_cmd):
 		tuple[str]: Version string, return code.
 	"""
 	from secator.runners import Command
-	import re
-	regex = r'[0-9]+\.[0-9]+\.?[0-9]*\.?[a-zA-Z]*'
 	ret = Command.execute(version_cmd, quiet=True, print_errors=False)
-	match = re.findall(regex, ret.output)
-	if not match:
-		console.print(Warning(message=f'Failed to find version in version command output. Command: {version_cmd}; Output: {ret.output}; Return code: {ret.return_code}'))  # noqa: E501
+	versions = get_versions_from_string(ret.output)
+	if not versions:
 		return None
-	return match[0]
+	return versions[0]
 
 
 def parse_version(ver):
@@ -437,7 +441,7 @@ def parse_version(ver):
 		return None
 
 
-def get_version_info(name, version_flag=None, install_github_handle=None, install_cmd=None, version=None):
+def get_version_info(name, version_flag=None, install_github_handle=None, install_cmd=None, install_version=None, version=None, bleeding=False):  # noqa: E501
 	"""Get version info for a command.
 
 	Args:
@@ -445,7 +449,9 @@ def get_version_info(name, version_flag=None, install_github_handle=None, instal
 		version_flag (str): Version flag.
 		install_github_handle (str): Github handle.
 		install_cmd (str): Install command.
+		install_version (str): Install version.
 		version (str): Existing version.
+		bleeding (bool): Bleeding edge.
 
 	Return:
 		dict: Version info.
@@ -457,10 +463,13 @@ def get_version_info(name, version_flag=None, install_github_handle=None, instal
 		'version': version,
 		'version_cmd': None,
 		'latest_version': None,
+		'install_version': None,
 		'location': None,
 		'status': '',
 		'outdated': False,
-		'errors': []
+		'bleeding': False,
+		'source': None,
+		'errors': [],
 	}
 
 	# Get binary path
@@ -472,41 +481,40 @@ def get_version_info(name, version_flag=None, install_github_handle=None, instal
 	info['location'] = location
 	info['installed'] = True
 
-	# Get latest version
+	# Get latest / recommanded version
 	latest_version = None
-	if not CONFIG.offline_mode:
-		if install_github_handle:
-			latest_version = GithubInstaller.get_latest_version(install_github_handle)
-			info['latest_version'] = latest_version
-		elif install_cmd and install_cmd.startswith('pip'):
-			req = requests.get(f'https://pypi.python.org/pypi/{name}/json')
-			version = parse_version('0')
-			if req.status_code == requests.codes.ok:
-				j = json.loads(req.text.encode(req.encoding))
-				releases = j.get('releases', [])
-				for release in releases:
-					ver = parse_version(release)
-					if ver and not ver.is_prerelease:
-						version = max(version, ver)
-						latest_version = str(version)
-						info['latest_version'] = latest_version
-		elif install_cmd and install_cmd.startswith('sudo apt install'):
-			ret = Command.execute(f'apt-cache madison {name}', quiet=True)
-			if ret.return_code == 0:
-				output = ret.output.split(' | ')
-				if len(output) > 1:
-					ver = parse_version(output[1].strip())
-					if ver:
-						latest_version = str(ver)
-						info['latest_version'] = latest_version
+	if install_version and not bleeding:
+		ver = parse_version(install_version)
+		info['latest_version'] = str(ver)
+		info['install_version'] = str(ver)
+		info['source'] = 'supported'
+		latest_version = str(ver)
+	else:
+		latest_version = None
+		if not CONFIG.offline_mode:
+			if install_github_handle:
+				latest_version = GithubInstaller.get_latest_version(install_github_handle)
+				info['latest_version'] = latest_version
+				info['source'] = 'github'
+			elif install_cmd and install_cmd.startswith('pip'):
+				req = requests.get(f'https://pypi.python.org/pypi/{name}/json')
+				version = parse_version('0')
+				if req.status_code == requests.codes.ok:
+					j = json.loads(req.text.encode(req.encoding))
+					releases = j.get('releases', [])
+					for release in releases:
+						ver = parse_version(release)
+						if ver and not ver.is_prerelease and not ver.is_postrelease and not ver.is_devrelease:
+							version = max(version, ver)
+							latest_version = str(version)
+							info['source'] = 'pypi'
 			else:
-				error = f'Failed to get latest version for {name}. Command: apt-cache madison {name}'
-				info['errors'].append(error)
-				console.print(Warning(message=error))
+				info['errors'].append('Cannot get latest version for query method (github, pip) is available')
+	info['latest_version'] = f'v{latest_version}' if install_version and install_version.startswith('v') else latest_version  # noqa: E501
 
 	# Get current version
 	version_flag = None if version_flag == OPT_NOT_SUPPORTED else version_flag
-	if version_flag:
+	if version_flag and not version:
 		version_cmd = f'{name} {version_flag}'
 		info['version_cmd'] = version_cmd
 		version = get_version(version_cmd)
@@ -518,11 +526,20 @@ def get_version_info(name, version_flag=None, install_github_handle=None, instal
 
 	# Check if up-to-date
 	if version and latest_version:
-		if parse_version(version) < parse_version(latest_version):
+		outdated = parse_version(version) < parse_version(latest_version)
+		equal = parse_version(version) == parse_version(latest_version)
+		if outdated:
 			info['status'] = 'outdated'
 			info['outdated'] = True
-		else:
+		elif equal:
 			info['status'] = 'latest'
+		else:
+			info['status'] = 'bleeding'
+			info['bleeding'] = True
+			if install_version:
+				info['errors'].append(f'Version {version} is greather than the recommended version {latest_version}')
+			else:
+				info['errors'].append(f'Version {version} is greather than the latest version {latest_version}')
 	elif not version:
 		info['status'] = 'current unknown'
 	elif not latest_version:
@@ -547,6 +564,7 @@ def get_distro_config():
 
 	if system == "Linux":
 		distrib = distro.like() or distro.id()
+		distrib = distrib.split(' ')[0] if distrib else None
 
 		if distrib in ["ubuntu", "debian", "linuxmint", "popos", "kali"]:
 			installer = "apt install -y --no-install-recommends"
@@ -593,22 +611,32 @@ def get_distro_config():
 def fmt_health_table_row(version_info, category=None):
 	name = version_info['name']
 	version = version_info['version']
+	if version:
+		version = version.lstrip('v')
 	status = version_info['status']
 	installed = version_info['installed']
 	latest_version = version_info['latest_version']
+	if latest_version:
+		latest_version = latest_version.lstrip('v')
+	source = version_info.get('source')
 	name_str = f'[magenta]{name:<13}[/]'
 
 	# Format version row
 	_version = version or ''
 	_version = f'[bold green]{_version:<10}[/]'
 	if status == 'latest':
-		_version += ' [bold green](latest)[/]'
+		_version += f' [bold green](latest {source})[/]'
+	elif status == 'bleeding':
+		msg = f'bleeding >{latest_version} {source}' if source else f'bleeding >{latest_version}'
+		_version += f' [bold orange1]({msg})[/]'
 	elif status == 'outdated':
 		_version += ' [bold red](outdated)[/]'
 		if latest_version:
-			_version += f' [dim](<{latest_version})'
+			_version += f' [dim](<{latest_version} {source})[/]'
 	elif status == 'missing':
 		_version = '[bold red]missing[/]'
+	elif status == 'missing_ok':
+		_version = '[dim green]not installed        [/]'
 	elif status == 'ok':
 		_version = '[bold green]ok        [/]'
 	elif status == 'version fetch error':

secator/loader.py

@@ -0,0 +1,116 @@
+from functools import cache
+from pkgutil import iter_modules
+from secator.rich import console
+from secator.config import CONFIG, CONFIGS_FOLDER
+from secator.template import TemplateLoader
+from secator.utils import debug
+from pathlib import Path
+import glob
+import importlib
+import inspect
+import sys
+
+
+@cache
+def find_templates():
+	discover_tasks()  # always load tasks first
+	results = []
+	dirs = [CONFIGS_FOLDER]
+	if CONFIG.dirs.templates:
+		dirs.append(CONFIG.dirs.templates)
+	paths = []
+	for dir in dirs:
+		config_paths = [
+			Path(path)
+			for path in glob.glob(str(dir).rstrip('/') + '/**/*.y*ml', recursive=True)
+		]
+		debug(f'Found {len(config_paths)} templates in {dir}', sub='template')
+		paths.extend(config_paths)
+	for path in paths:
+		config = TemplateLoader(input=path)
+		debug(f'Loaded template from {path}', sub='template')
+		results.append(config)
+	return results
+
+
+@cache
+def get_configs_by_type(type):
+	if type == 'task':
+		tasks = discover_tasks()
+		task_config = [TemplateLoader({'name': cls.__name__, 'type': 'task', 'input_types': cls.input_types, 'output_types': [t.get_name() for t in cls.output_types]}) for cls in tasks]  # noqa: E501
+		return sorted(task_config, key=lambda x: x['name'])
+	return sorted([t for t in find_templates() if t.type == type], key=lambda x: x.name)
+
+
+@cache
+def discover_tasks():
+	"""Find all secator tasks (internal + external)."""
+	return discover_internal_tasks() + discover_external_tasks()
+
+
+@cache
+def discover_internal_tasks():
+	"""Find internal secator tasks."""
+	from secator.runners import Runner
+	package_dir = Path(__file__).resolve().parent / 'tasks'
+	task_classes = []
+	for (_, module_name, _) in iter_modules([str(package_dir)]):
+		if module_name.startswith('_'):
+			continue
+		try:
+			module = importlib.import_module(f'secator.tasks.{module_name}')
+		except ImportError as e:
+			console.print(f'[bold red]Could not import secator.tasks.{module_name}:[/]')
+			console.print(f'\t[bold red]{type(e).__name__}[/]: {str(e)}')
+			continue
+		for attribute_name in dir(module):
+			attribute = getattr(module, attribute_name)
+			if inspect.isclass(attribute):
+				bases = inspect.getmro(attribute)
+				if Runner in bases and hasattr(attribute, '__task__'):
+					attribute.__external__ = False
+					task_classes.append(attribute)
+
+	# Sort task_classes by category
+	task_classes = sorted(
+		task_classes,
+		# key=lambda x: (get_command_category(x), x.__name__)
+		key=lambda x: x.__name__)
+	return task_classes
+
+
+@cache
+def discover_external_tasks():
+	"""Find external secator tasks."""
+	output = []
+	prev_state = sys.dont_write_bytecode
+	sys.dont_write_bytecode = True
+	for path in CONFIG.dirs.templates.glob('**/*.py'):
+		try:
+			task_name = path.stem
+			module_name = f'secator.tasks.{task_name}'
+
+			# console.print(f'Importing module {module_name} from {path}')
+			spec = importlib.util.spec_from_file_location(module_name, path)
+			module = importlib.util.module_from_spec(spec)
+			if not spec:
+				console.print(f'[bold red]Could not load external module {path.name}: invalid import spec.[/] ({path})')
+				continue
+			# console.print(f'Adding module "{module_name}" to sys path')
+			sys.modules[module_name] = module
+
+			# console.print(f'Executing module "{module}"')
+			spec.loader.exec_module(module)
+
+			# console.print(f'Checking that {module} contains task {task_name}')
+			if not hasattr(module, task_name):
+				console.print(f'[bold orange1]Could not load external task "{task_name}" from module {path.name}[/] ({path})')
+				continue
+			cls = getattr(module, task_name)
+			console.print(f'[bold green]Successfully loaded external task "{task_name}"[/] ({path})')
+			cls.__external__ = True
+			output.append(cls)
+		except Exception as e:
+			console.print(f'[bold red]Could not load external module {path.name}. Reason: {str(e)}.[/] ({path})')
+	sys.dont_write_bytecode = prev_state
+	return output

secator/output_types/_base.py

@@ -12,6 +12,9 @@ class OutputType:
 	_table_fields = []
 	_sort_by = ()
 
+	def __str__(self):
+		return self.__class__.__name__
+
 	def __gt__(self, other):
 		if not self.__eq__(other):
 			return False

secator/output_types/certificate.py

@@ -8,71 +8,71 @@ from secator.definitions import CERTIFICATE_STATUS_UNKNOWN
 
 @dataclass
 class Certificate(OutputType):
-    host: str
-    fingerprint_sha256: str = field(default='')
-    ip: str = field(default='', compare=False)
-    raw_value: str = field(default='', compare=False)
-    subject_cn: str = field(default='', compare=False)
-    subject_an: list[str] = field(default_factory=list, compare=False)
-    not_before: datetime = field(default=None, compare=False)
-    not_after: datetime = field(default=None, compare=False)
-    issuer_dn: str = field(default='', compare=False)
-    issuer_cn: str = field(default='', compare=False)
-    issuer: str = field(default='', compare=False)
-    self_signed: bool = field(default=True, compare=False)
-    trusted: bool = field(default=False, compare=False)
-    status: str = field(default=CERTIFICATE_STATUS_UNKNOWN, compare=False)
-    keysize: int = field(default=None, compare=False)
-    serial_number: str = field(default='', compare=False)
-    ciphers: list[str] = field(default_factory=list, compare=False)
-    # parent_certificate: 'Certificate' = None  # noqa: F821
-    _source: str = field(default='', repr=True)
-    _type: str = field(default='certificate', repr=True)
-    _timestamp: int = field(default_factory=lambda: time.time(), compare=False)
-    _uuid: str = field(default='', repr=True, compare=False)
-    _context: dict = field(default_factory=dict, repr=True, compare=False)
-    _tagged: bool = field(default=False, repr=True, compare=False)
-    _duplicate: bool = field(default=False, repr=True, compare=False)
-    _related: list = field(default_factory=list, compare=False)
-    _table_fields = ['ip', 'host']
-    _sort_by = ('ip',)
+	host: str
+	fingerprint_sha256: str = field(default='')
+	ip: str = field(default='', compare=False)
+	raw_value: str = field(default='', compare=False)
+	subject_cn: str = field(default='', compare=False)
+	subject_an: list[str] = field(default_factory=list, compare=False)
+	not_before: datetime = field(default=None, compare=False)
+	not_after: datetime = field(default=None, compare=False)
+	issuer_dn: str = field(default='', compare=False)
+	issuer_cn: str = field(default='', compare=False)
+	issuer: str = field(default='', compare=False)
+	self_signed: bool = field(default=True, compare=False)
+	trusted: bool = field(default=False, compare=False)
+	status: str = field(default=CERTIFICATE_STATUS_UNKNOWN, compare=False)
+	keysize: int = field(default=None, compare=False)
+	serial_number: str = field(default='', compare=False)
+	ciphers: list[str] = field(default_factory=list, compare=False)
+	# parent_certificate: 'Certificate' = None  # noqa: F821
+	_source: str = field(default='', repr=True)
+	_type: str = field(default='certificate', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+	_table_fields = ['ip', 'host']
+	_sort_by = ('ip',)
 
-    def __str__(self) -> str:
-        return self.subject_cn
+	def __str__(self) -> str:
+		return self.subject_cn
 
-    def is_expired(self) -> bool:
-        if self.not_after:
-            return self.not_after < datetime.now()
-        return True
+	def is_expired(self) -> bool:
+		if self.not_after:
+			return self.not_after < datetime.now()
+		return True
 
-    def is_expired_soon(self, months: int = 1) -> bool:
-        if self.not_after:
-            return self.not_after < datetime.now() + timedelta(days=months * 30)
-        return True
+	def is_expired_soon(self, months: int = 1) -> bool:
+		if self.not_after:
+			return self.not_after < datetime.now() + timedelta(days=months * 30)
+		return True
 
-    @staticmethod
-    def format_date(date):
-        if date:
-            return date.strftime("%m/%d/%Y")
-        return '?'
+	@staticmethod
+	def format_date(date):
+		if date:
+			return date.strftime("%m/%d/%Y")
+		return '?'
 
-    def __repr__(self) -> str:
-        s = f'📜 [bold white]{self.host}[/]'
-        s += f' [cyan]{self.status}[/]'
-        s += rf' [white]\[fingerprint={self.fingerprint_sha256[:10]}][/]'
-        if self.subject_cn:
-            s += rf' [white]\[cn={self.subject_cn}][/]'
-        if self.subject_an:
-            s += rf' [white]\[an={", ".join(self.subject_an)}][/]'
-        if self.issuer:
-            s += rf' [white]\[issuer={self.issuer}][/]'
-        elif self.issuer_cn:
-            s += rf' [white]\[issuer_cn={self.issuer_cn}][/]'
-        expiry_date = Certificate.format_date(self.not_after)
-        if self.is_expired():
-            s += f' [red]expired since {expiry_date}[/red]'
-        elif self.is_expired_soon(months=2):
-            s += f' [yellow]expires <2 months[/yellow], [yellow]valid until {expiry_date}[/yellow]'
-        else:
-            s += f' [green]not expired[/green], [yellow]valid until {expiry_date}[/yellow]'
-        return rich_to_ansi(s)
+	def __repr__(self) -> str:
+		s = f'📜 [bold white]{self.host}[/]'
+		s += f' [cyan]{self.status}[/]'
+		s += rf' [white]\[fingerprint={self.fingerprint_sha256[:10]}][/]'
+		if self.subject_cn:
+			s += rf' [white]\[cn={self.subject_cn}][/]'
+		if self.subject_an:
+			s += rf' [white]\[an={", ".join(self.subject_an)}][/]'
+		if self.issuer:
+			s += rf' [white]\[issuer={self.issuer}][/]'
+		elif self.issuer_cn:
+			s += rf' [white]\[issuer_cn={self.issuer_cn}][/]'
+		expiry_date = Certificate.format_date(self.not_after)
+		if self.is_expired():
+			s += f' [red]expired since {expiry_date}[/red]'
+		elif self.is_expired_soon(months=2):
+			s += f' [yellow]expires <2 months[/yellow], [yellow]valid until {expiry_date}[/yellow]'
+		else:
+			s += f' [green]not expired[/green], [yellow]valid until {expiry_date}[/yellow]'
+		return rich_to_ansi(s)

secator/output_types/error.py

@@ -22,20 +22,19 @@ class Error(OutputType):
 
 	def from_exception(e, **kwargs):
 		errtype = type(e).__name__
-		message = errtype
 		if str(e):
-			message += f': {str(e)}'
+			errtype += f': {str(e)}'
+		message = kwargs.pop('message', errtype)
 		traceback = traceback_as_string(e) if errtype not in ['KeyboardInterrupt', 'GreenletExit'] else ''
-		error = Error(message=message, traceback=traceback, **kwargs)
+		error = Error(message=_s(message), traceback=traceback, **kwargs)
 		return error
 
 	def __str__(self):
 		return self.message
 
 	def __repr__(self):
-		s = rf"\[[bold red]ERR[/]] {_s(self.message)}"
+		s = rf"\[[bold red]ERR[/]] {self.message}"
 		if self.traceback:
-			s += ':'
 			traceback_pretty = '   ' + _s(self.traceback).replace('\n', '\n   ')
 			if self.traceback_title:
 				traceback_pretty = f'   {self.traceback_title}:\n{traceback_pretty}'

secator/output_types/info.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 import time
 from secator.output_types import OutputType
-from secator.utils import rich_to_ansi, rich_escape as _s
+from secator.utils import rich_to_ansi
 
 
 @dataclass
@@ -20,5 +20,5 @@ class Info(OutputType):
 	_sort_by = ('_timestamp',)
 
 	def __repr__(self):
-		s = rf"\[[blue]INF[/]] {_s(self.message)}"
+		s = rf"\[[blue]INF[/]] {self.message}"
 		return rich_to_ansi(s)

secator/output_types/ip.py

@@ -15,7 +15,7 @@ class IpProtocol(str, Enum):
 @dataclass
 class Ip(OutputType):
 	ip: str
-	host: str = ''
+	host: str = field(default='', repr=True, compare=False)
 	alive: bool = False
 	protocol: str = field(default=IpProtocol.IPv4)
 	_source: str = field(default='', repr=True)
@@ -37,4 +37,6 @@ class Ip(OutputType):
 		s = f'💻 [bold white]{self.ip}[/]'
 		if self.host:
 			s += rf' \[[bold magenta]{self.host}[/]]'
+		if self.alive:
+			s += r' [bold green]🟢[/]'
 		return rich_to_ansi(s)

secator/output_types/progress.py

@@ -2,14 +2,12 @@ import time
 from dataclasses import dataclass, field
 
 from secator.output_types import OutputType
-from secator.utils import rich_to_ansi
+from secator.utils import rich_to_ansi, format_object
 
 
 @dataclass
 class Progress(OutputType):
-	duration: str
 	percent: int = 0
-	errors: list = field(default_factory=list)
 	extra_data: dict = field(default_factory=dict)
 	_source: str = field(default='', repr=True)
 	_type: str = field(default='progress', repr=True)
@@ -20,7 +18,7 @@ class Progress(OutputType):
 	_duplicate: bool = field(default=False, repr=True, compare=False)
 	_related: list = field(default_factory=list, compare=False)
 
-	_table_fields = ['percent', 'duration']
+	_table_fields = ['percent']
 	_sort_by = ('percent',)
 
 	def __post_init__(self):
@@ -32,9 +30,7 @@ class Progress(OutputType):
 		return f'{self.percent}%'
 
 	def __repr__(self) -> str:
-		s = f'[dim]⏳ {self.percent}% ' + '█' * (self.percent // 10) + '[/]'
-		if self.errors:
-			s += f' [dim red]errors={self.errors}[/]'
-		ed = ' '.join([f'{k}={v}' for k, v in self.extra_data.items() if k != 'startedAt' and v])
-		s += f' [dim yellow]{ed}[/]'
+		s = f'[dim]⏳ [bold]{self.percent}%[/] ' + '█' * (self.percent // 10) + '[/]'
+		ed = format_object(self.extra_data, color='yellow3', skip_keys=['startedAt'])
+		s += f'[dim]{ed}[/]'
 		return rich_to_ansi(s)

secator/output_types/state.py

@@ -7,23 +7,23 @@ from secator.utils import rich_to_ansi
 
 @dataclass
 class State(OutputType):
-    """Represents the state of a Celery task."""
+	"""Represents the state of a Celery task."""
 
-    task_id: str
-    state: str
-    _type: str = field(default='state', repr=True)
-    _source: str = field(default='', repr=True)
-    _timestamp: int = field(default_factory=lambda: time.time(), compare=False)
-    _uuid: str = field(default='', repr=True, compare=False)
-    _context: dict = field(default_factory=dict, repr=True, compare=False)
-    _tagged: bool = field(default=False, repr=True, compare=False)
-    _duplicate: bool = field(default=False, repr=True, compare=False)
-    _related: list = field(default_factory=list, compare=False)
-    _icon = '📊'
-    _color = 'bright_blue'
+	task_id: str
+	state: str
+	_type: str = field(default='state', repr=True)
+	_source: str = field(default='', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+	_icon = '📊'
+	_color = 'bright_blue'
 
-    def __str__(self) -> str:
-        return f"Task {self.task_id} is {self.state}"
+	def __str__(self) -> str:
+		return f"Task {self.task_id} is {self.state}"
 
-    def __repr__(self) -> str:
-        return rich_to_ansi(f"{self._icon} [bold {self._color}]{self.state}[/] {self.task_id}")
+	def __repr__(self) -> str:
+		return rich_to_ansi(f"{self._icon} [bold {self._color}]{self.state}[/] {self.task_id}")

secator/output_types/tag.py

@@ -10,6 +10,7 @@ class Tag(OutputType):
 	name: str
 	match: str
 	extra_data: dict = field(default_factory=dict, repr=True, compare=False)
+	stored_response_path: str = field(default='', compare=False)
 	_source: str = field(default='', repr=True)
 	_type: str = field(default='tag', repr=True)
 	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
@@ -32,6 +33,8 @@ class Tag(OutputType):
 		s = f'🏷️  [bold magenta]{self.name}[/]'
 		s += f' found @ [bold]{_s(self.match)}[/]'
 		ed = ''
+		if self.stored_response_path:
+			s += rf' [link=file://{self.stored_response_path}]:incoming_envelope:[/]'
 		if self.extra_data:
 			for k, v in self.extra_data.items():
 				sep = ' '