secator 0.22.0__py3-none-any.whl

secator/loader.py

@@ -0,0 +1,128 @@
+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',
+			'description': cls.__doc__,
+			'input_types': cls.input_types,
+			'output_types': [t.get_name() for t in cls.output_types],
+			'default_inputs': cls.default_inputs,
+			'proxychains': getattr(cls, 'proxychains', True),
+			'proxy_socks5': getattr(cls, 'proxy_socks5', True),
+			'proxy_http': getattr(cls, 'proxy_http', True),
+			'default_cmd': getattr(cls, 'cmd', None),
+			'install_cmd': getattr(cls, 'install_cmd', None),
+		}) 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/__init__.py

@@ -0,0 +1,49 @@
+__all__ = [
+	'Domain',
+	'Error',
+	'OutputType',
+	'Info',
+	'Ip',
+	'Port',
+	'Progress',
+	'Record',
+	'Stat',
+	'State',
+	'Subdomain',
+	'Url',
+	'UrlParam',
+	'UserAccount',
+	'Vulnerability',
+	'Warning',
+]
+from secator.output_types._base import OutputType
+from secator.output_types.progress import Progress
+from secator.output_types.ip import Ip
+from secator.output_types.exploit import Exploit
+from secator.output_types.port import Port
+from secator.output_types.subdomain import Subdomain
+from secator.output_types.tag import Tag
+from secator.output_types.target import Target
+from secator.output_types.url import Url
+from secator.output_types.user_account import UserAccount
+from secator.output_types.vulnerability import Vulnerability
+from secator.output_types.record import Record
+from secator.output_types.certificate import Certificate
+from secator.output_types.info import Info
+from secator.output_types.warning import Warning
+from secator.output_types.error import Error
+from secator.output_types.stat import Stat
+from secator.output_types.state import State
+from secator.output_types.domain import Domain
+
+
+EXECUTION_TYPES = [
+	Target, Progress, Info, Warning, Error, State
+]
+STAT_TYPES = [
+	Stat
+]
+FINDING_TYPES = [
+	Subdomain, Ip, Port, Url, Tag, Exploit, UserAccount, Vulnerability, Certificate, Record, Domain
+]
+OUTPUT_TYPES = FINDING_TYPES + EXECUTION_TYPES + STAT_TYPES

secator/output_types/_base.py

@@ -0,0 +1,108 @@
+import logging
+import re
+from dataclasses import _MISSING_TYPE, dataclass, fields
+from secator.definitions import DEBUG
+from secator.rich import console
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OutputType:
+	_table_fields = []
+	_sort_by = ()
+
+	def __str__(self):
+		return self.__class__.__name__
+
+	def __gt__(self, other):
+		if not self.__eq__(other):
+			return False
+
+		# Point-based system based on number of non-empty extra-data present.
+		# In this configuration, a > b if a == b AND a has more non-empty fields than b
+		# extra_fields = [f for f in fields(self) if not f.compare]
+		# points1 = 0
+		# points2 = 0
+		# for field in extra_fields:
+		# 	v1 = getattr(self, field.name)
+		# 	v2 = getattr(other, field.name)
+		# 	if v1 and not v2:
+		# 		points1 += 1
+		# 	elif v2 and not v1:
+		# 		points2 += 1
+		# if points1 > points2:
+		# 	return True
+
+		# Timestamp-based system: return newest object
+		return self._timestamp > other._timestamp
+
+	def __ge__(self, other):
+		return self == other
+
+	def __lt__(self, other):
+		return other > self
+
+	def __le__(self, other):
+		return self == other
+
+	def __post_init__(self):
+		"""Initialize default fields to their proper types."""
+		for field in fields(self):
+			default_factory = field.default_factory
+			default = field.default
+			if getattr(self, field.name) is None:
+				if not isinstance(default, _MISSING_TYPE):
+					setattr(self, field.name, field.default)
+				elif not isinstance(default_factory, _MISSING_TYPE):
+					setattr(self, field.name, default_factory())
+
+	@classmethod
+	def load(cls, item, output_map={}):
+		new_item = {}
+
+		# Check for explicit _type keys
+		_type = item.get('_type')
+		if _type and _type != cls.get_name():
+			raise TypeError(f'Item has different _type set: {_type}')
+
+		for field in fields(cls):
+			key = field.name
+			if key in output_map:
+				mapped_key = output_map[key]
+				if callable(mapped_key):
+					try:
+						mapped_val = mapped_key(item)
+					except Exception as e:
+						mapped_val = None
+						if DEBUG > 1:
+							console.print_exception(show_locals=True)
+						raise TypeError(
+							f'Fail to transform value for "{key}" using output_map function. Exception: '
+							f'{type(e).__name__}: {str(e)}')
+				else:
+					mapped_val = item.get(mapped_key)
+				new_item[key] = mapped_val
+			elif key in item:
+				new_item[key] = item[key]
+
+		# All values None, raise an error
+		if all(val is None for val in new_item.values()):
+			raise TypeError(f'Item does not match {cls} schema')
+
+		new_item['_type'] = cls.get_name()
+		return cls(**new_item)
+
+	@classmethod
+	def get_name(cls):
+		return re.sub(r'(?<!^)(?=[A-Z])', '_', cls.__name__).lower()
+
+	@classmethod
+	def keys(cls):
+		return [f.name for f in fields(cls)]
+
+	def toDict(self, exclude=[]):
+		data = self.__dict__.copy()
+		if exclude:
+			return {k: v for k, v in data.items() if k not in exclude}
+		return data

secator/output_types/certificate.py

@@ -0,0 +1,78 @@
+import time
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi
+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, compare=False)
+	_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 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
+
+	@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)

secator/output_types/domain.py

@@ -0,0 +1,50 @@
+import time
+from datetime import datetime
+from dataclasses import dataclass, field
+
+from secator.definitions import ALIVE, DOMAIN
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, format_object
+
+
+@dataclass
+class Domain(OutputType):
+	domain: str
+	registrar: str = ''
+	alive: bool = False
+	creation_date: str = ''
+	expiration_date: str = ''
+	registrant: str = ''
+	extra_data: dict = field(default_factory=dict, compare=False)
+	_source: str = field(default='', repr=True)
+	_type: str = field(default='domain', 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 = [DOMAIN, ALIVE]
+	_sort_by = (DOMAIN,)
+
+	def __str__(self) -> str:
+		return self.domain
+
+	def __repr__(self) -> str:
+		s = f'🪪  [bold white]{self.domain}[/]'
+		if self.registrant:
+			s += rf' \[[bold magenta]{self.registrant}[/]]'
+		if self.registrar:
+			s += rf' \[[bold blue]{self.registrar}[/]]'
+		if self.expiration_date:
+			now = datetime.now()
+			expiration_date_strptime = datetime.strptime(self.expiration_date, "%Y-%m-%d %H:%M:%S")
+			if expiration_date_strptime < now:
+				s += rf' \[[bold red]{self.expiration_date}[/]]'
+			else:
+				s += rf' \[[bold green]{self.expiration_date}[/]]'
+		if self.extra_data:
+			s += format_object(self.extra_data, 'yellow')
+
+		return rich_to_ansi(s)

secator/output_types/error.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, field
+import time
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, traceback_as_string, rich_escape as _s
+
+
+@dataclass
+class Error(OutputType):
+	message: str
+	traceback: str = field(default='', compare=False)
+	traceback_title: str = field(default='', compare=False)
+	_source: str = field(default='', repr=True)
+	_type: str = field(default='error', 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)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = ['message', 'traceback']
+	_sort_by = ('_timestamp',)
+
+	def from_exception(e, **kwargs):
+		errtype = type(e).__name__
+		if 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=_s(message), traceback=traceback, **kwargs)
+		return error
+
+	def __str__(self):
+		return self.message
+
+	def __repr__(self):
+		s = rf"\[[bold red]ERR[/]] {self.message}"
+		if self.traceback:
+			traceback_pretty = '   ' + _s(self.traceback).replace('\n', '\n   ')
+			if self.traceback_title:
+				traceback_pretty = f'   {self.traceback_title}:\n{traceback_pretty}'
+			s += f'\n[dim]{_s(traceback_pretty)}[/]'
+		return rich_to_ansi(s)

secator/output_types/exploit.py

@@ -0,0 +1,58 @@
+import time
+from dataclasses import dataclass, field
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, rich_escape as _s, format_object
+from secator.definitions import MATCHED_AT, NAME, ID, EXTRA_DATA, REFERENCE
+
+
+@dataclass
+class Exploit(OutputType):
+	name: str
+	provider: str
+	id: str
+	matched_at: str = ''
+	ip: str = ''
+	confidence: str = 'low'
+	reference: str = field(default='', repr=True, compare=False)
+	cves: list = field(default_factory=list, compare=False)
+	tags: list = field(default_factory=list, compare=False)
+	extra_data: dict = field(default_factory=dict, compare=False)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='exploit', 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 = [
+		MATCHED_AT,
+		NAME,
+		ID,
+		EXTRA_DATA,
+		REFERENCE
+	]
+	_sort_by = ('matched_at', 'name')
+
+	def __str__(self):
+		return self.name
+
+	def __repr__(self):
+		s = rf'[bold red]⍼[/]  \[[bold red]{self.name}'
+		if self.reference:
+			s += f' [link={_s(self.reference)}]🡕[/link]'
+		s += '[/]]'
+		if self.matched_at:
+			s += f' {_s(self.matched_at)}'
+		if self.cves:
+			cves_str = ', '.join(self.cves)
+			s += rf' \[[red]{cves_str}[/]]'
+		if self.tags:
+			tags_str = ', '.join(self.tags)
+			s += rf' \[[cyan]{tags_str}[/]]'
+		if self.extra_data:
+			s += format_object(self.extra_data, 'yellow')
+		if self.confidence == 'low':
+			s = f'[dim]{s}[/]'
+		return rich_to_ansi(s)

secator/output_types/info.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+import time
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi
+
+
+@dataclass
+class Info(OutputType):
+	message: str
+	task_id: str = field(default='', compare=False)
+	_source: str = field(default='', repr=True)
+	_type: str = field(default='info', 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)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = ['message', 'task_id']
+	_sort_by = ('_timestamp',)
+
+	def __repr__(self):
+		s = rf"\[[blue]INF[/]] {self.message}"
+		return rich_to_ansi(s)

secator/output_types/ip.py

@@ -0,0 +1,47 @@
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+
+from secator.definitions import ALIVE, IP
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, format_object
+
+
+class IpProtocol(str, Enum):
+	IPv6 = 'IPv6'
+	IPv4 = 'IPv4'
+
+
+@dataclass
+class Ip(OutputType):
+	ip: str
+	host: str = field(default='', repr=True, compare=False)
+	alive: bool = False
+	protocol: str = field(default=IpProtocol.IPv4)
+	extra_data: dict = field(default_factory=dict, compare=False)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='ip', 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, ALIVE]
+	_sort_by = (IP,)
+
+	def __str__(self) -> str:
+		return self.ip
+
+	def __repr__(self) -> str:
+		s = f'💻 [bold white]{self.ip}[/]'
+		if self.host and self.host != self.ip:
+			s += rf' \[[bold magenta]{self.host}[/]]'
+		if self.alive:
+			s += r' \[[bold green]alive[/]]'
+		if self.extra_data:
+			s += format_object(self.extra_data, 'yellow')
+		if not self.alive:
+			s = f'[dim]{s}[/]'
+		return rich_to_ansi(s)

secator/output_types/port.py

@@ -0,0 +1,55 @@
+import time
+from dataclasses import dataclass, field
+
+from secator.definitions import CPES, EXTRA_DATA, HOST, IP, PORT
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, format_object
+
+
+@dataclass
+class Port(OutputType):
+	port: int
+	ip: str
+	state: str = 'UNKNOWN'
+	service_name: str = field(default='', compare=False)
+	cpes: list = field(default_factory=list, compare=False)
+	host: str = field(default='', repr=True, compare=False)
+	protocol: str = field(default='tcp', repr=True, compare=False)
+	extra_data: dict = field(default_factory=dict, compare=False)
+	confidence: str = field(default='low', repr=False, compare=False)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='port', repr=True)
+	_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, PORT, HOST, CPES, EXTRA_DATA]
+	_sort_by = (PORT, IP)
+
+	def __gt__(self, other):
+		# favor nmap over other port detection tools
+		if self._source == 'nmap' and other._source != 'nmap':
+			return True
+		return super().__gt__(other)
+
+	def __str__(self) -> str:
+		return f'{self.host}:{self.port}'
+
+	def __repr__(self) -> str:
+		s = f'🔓 {self.ip}:[bold red]{self.port:<4}[/] [bold yellow]{self.state.upper()}[/]'
+		if self.protocol != 'TCP':
+			s += rf' \[[yellow3]{self.protocol}[/]]'
+		if self.service_name:
+			conf = ''
+			if self.confidence == 'low':
+				conf = '[bold orange3]?[/]'
+			s += rf' \[[bold purple]{self.service_name}{conf}[/]]'
+		if self.host and self.host != self.ip:
+			s += rf' \[[cyan]{self.host}[/]]'
+		if self.extra_data:
+			skip_keys = ['name', 'servicefp', 'method', 'service_name', 'product', 'version', 'conf']
+			s += format_object(self.extra_data, 'yellow', skip_keys=skip_keys)
+		return rich_to_ansi(s)

secator/output_types/progress.py

@@ -0,0 +1,36 @@
+import time
+from dataclasses import dataclass, field
+
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, format_object
+
+
+@dataclass
+class Progress(OutputType):
+	percent: int = 0
+	extra_data: dict = field(default_factory=dict)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='progress', 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 = ['percent']
+	_sort_by = ('percent',)
+
+	def __post_init__(self):
+		super().__post_init__()
+		if not 0 <= self.percent <= 100:
+			self.percent = 0
+
+	def __str__(self) -> str:
+		return f'{self.percent}%'
+
+	def __repr__(self) -> str:
+		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)