secator 0.22.0__py3-none-any.whl

secator/tasks/xurlfind3r.py

@@ -0,0 +1,83 @@
+import validators
+from collections import defaultdict
+from urllib.parse import urlparse, urlunparse, parse_qs
+
+from secator.definitions import HOST, URL, DELAY, DEPTH, FILTER_CODES, FILTER_REGEX, FILTER_SIZE, FILTER_WORDS, MATCH_CODES, MATCH_REGEX, MATCH_SIZE, MATCH_WORDS, FOLLOW_REDIRECT, METHOD, PROXY, RATE_LIMIT, RETRIES, THREADS, TIMEOUT, USER_AGENT, HEADER, OPT_NOT_SUPPORTED  # noqa: E501
+from secator.output_types import Url
+from secator.decorators import task
+from secator.serializers import JSONSerializer
+from secator.tasks._categories import HttpCrawler
+
+MAX_PARAM_OCCURRENCES = 10
+
+
+@task()
+class xurlfind3r(HttpCrawler):
+	"""Discover URLs for a given domain in a simple, passive and efficient way"""
+	cmd = 'xurlfind3r'
+	tags = ['url', 'recon']
+	input_types = [HOST, URL]
+	output_types = [Url]
+	item_loaders = [JSONSerializer()]
+	json_flag = '--jsonl'
+	file_flag = '-l'
+	input_flag = '-d'
+	version_flag = 'version'
+	opts = {
+		'sources': {'type': str, 'help': 'Sources to use (comma-delimited)', 'required': False},
+		'sources_to_exclude': {'type': str, 'help': 'Sources to exclude (comma-delimited)', 'required': False},
+		'include_subdomains': {'is_flag': True, 'help': 'Include subdomains', 'required': False, 'default': False},
+		'max_param_occurrences': {'type': int, 'help': 'Max occurrences for the same parameter in the same URL before discarding next results', 'required': False, 'default': 10, 'internal': True},  # noqa: E501
+	}
+	opt_key_map = {
+		HEADER: OPT_NOT_SUPPORTED,
+		DELAY: OPT_NOT_SUPPORTED,
+		DEPTH: OPT_NOT_SUPPORTED,
+		FILTER_CODES: OPT_NOT_SUPPORTED,
+		FILTER_REGEX: OPT_NOT_SUPPORTED,
+		FILTER_SIZE: OPT_NOT_SUPPORTED,
+		FILTER_WORDS: OPT_NOT_SUPPORTED,
+		MATCH_CODES: OPT_NOT_SUPPORTED,
+		MATCH_REGEX: OPT_NOT_SUPPORTED,
+		MATCH_SIZE: OPT_NOT_SUPPORTED,
+		MATCH_WORDS: OPT_NOT_SUPPORTED,
+		FOLLOW_REDIRECT: OPT_NOT_SUPPORTED,
+		METHOD: OPT_NOT_SUPPORTED,
+		PROXY: OPT_NOT_SUPPORTED,
+		RATE_LIMIT: OPT_NOT_SUPPORTED,
+		RETRIES: OPT_NOT_SUPPORTED,
+		THREADS: OPT_NOT_SUPPORTED,
+		TIMEOUT: OPT_NOT_SUPPORTED,
+		USER_AGENT: OPT_NOT_SUPPORTED,
+	}
+	install_version = '1.3.0'
+	install_cmd = 'go install -v github.com/hueristiq/xurlfind3r/cmd/xurlfind3r@[install_version]'
+	github_handle = 'hueristiq/xurlfind3r'
+	proxychains = False
+	proxy_socks5 = True
+	proxy_http = True
+	profile = 'io'
+
+	@staticmethod
+	def before_init(self):
+		for idx, input in enumerate(self.inputs):
+			if validators.url(input):
+				self.inputs[idx] = urlparse(input).netloc
+
+	@staticmethod
+	def on_init(self):
+		self.max_param_occurrences = self.get_opt_value('max_param_occurrences')
+		self.seen_params = defaultdict(lambda: defaultdict(int))
+
+	@staticmethod
+	def on_json_loaded(self, item):
+		url = item['url']
+		parsed_url = urlparse(url)
+		base_url = urlunparse(parsed_url._replace(query="", fragment=""))  # Remove query & fragment
+		query_params = parse_qs(parsed_url.query)
+		current_params = set(query_params.keys())
+		for param in current_params:
+			self.seen_params[base_url][param] += 1
+			if self.seen_params[base_url][param] > int(self.max_param_occurrences):
+				return
+		yield Url(url=item['url'], host=parsed_url.hostname, extra_data={'source': item['source']})

secator/template.py

@@ -0,0 +1,294 @@
+import yaml
+
+from collections import OrderedDict
+from dotmap import DotMap
+from pathlib import Path
+
+from secator.output_types import Error
+from secator.rich import console
+
+
+class TemplateLoader(DotMap):
+
+	def __init__(self, input={}, name=None, **kwargs):
+		if name:
+			split = name.split('/')
+			if len(split) != 2:
+				console.print(Error(message=f'Cannot load {name}: you should specify a type for the template when loading by name (e.g. workflow/<workflow_name>)'))  # noqa: E501
+				return
+			_type, _name = tuple(split)
+			if _type.endswith('s'):
+				_type = _type[:-1]
+			from secator.loader import find_templates
+			config = next((p for p in find_templates() if p['type'] == _type and p['name'] == _name), None)
+			if not config:
+				console.print(Error(message=f'Template {_type}/{_name} not found in loaded templates'))
+				config = {}
+		elif isinstance(input, dict):
+			config = input
+		elif isinstance(input, Path) or Path(input).exists():
+			config = self._load_from_path(input)
+			config['_path'] = str(input)
+		elif isinstance(input, str):
+			config = self._load(input)
+		super().__init__(config, **kwargs)
+
+	def _load_from_path(self, path):
+		if not path.exists():
+			console.print(Error(message=f'Config path {path} does not exists'))
+			return
+		with path.open('r') as f:
+			return self._load(f.read())
+
+	def _load(self, input):
+		return yaml.load(input, Loader=yaml.Loader)
+
+	def print(self):
+		"""Print config as highlighted yaml."""
+		config = self.toDict()
+		_path = config.pop('_path', None)
+		if _path:
+			console.print(f'[italic green]{_path}[/]\n')
+		yaml_str = yaml.dump(config, indent=4, sort_keys=False)
+		from rich.syntax import Syntax
+		yaml_highlight = Syntax(yaml_str, 'yaml', line_numbers=True)
+		console.print(yaml_highlight)
+
+
+def get_short_id(id_str, config_name):
+	"""Remove config name prefix from ID string if present.
+
+	Args:
+		id_str: The ID string to process
+		config_name: The config name prefix to remove
+
+	Returns:
+		str: ID string with prefix removed, or original string if no prefix found
+	"""
+	if id_str.startswith(config_name):
+		return id_str.replace(config_name + '.', '')
+	return id_str
+
+
+def get_config_options(config, exec_opts=None, output_opts=None, type_mapping=None):
+	"""Extract and normalize command-line options from configuration.
+
+	Args:
+		config: Configuration object (task, workflow, or scan)
+		exec_opts: Execution options dictionary (optional)
+		output_opts: Output options dictionary (optional)
+		type_mapping: Type mapping for option types (optional)
+
+	Returns:
+		OrderedDict: Normalized options with metadata
+	"""
+	from secator.tree import build_runner_tree, walk_runner_tree, get_flat_node_list
+	from secator.utils import debug
+	from secator.runners.task import Task
+
+	# Task config created on-the-fly
+	if config.type == 'task':
+		config = TemplateLoader({
+			'name': config.name,
+			'type': 'workflow',
+			'tasks': {config.name: {}}
+		})
+
+	# Get main info
+	tree = build_runner_tree(config)
+	nodes = get_flat_node_list(tree)
+	exec_opts = exec_opts or {}
+	output_opts = output_opts or {}
+	type_mapping = type_mapping or {}
+	all_opts = OrderedDict({})
+
+	# Log current config and tree
+	debug(f'[magenta]{config.name}[/]', sub=f'cli.{config.name}')
+	debug(f'{tree.render_tree()}', sub=f'cli.{config.name}')
+
+	# Process global execution options
+	for opt in exec_opts:
+		opt_conf = exec_opts[opt].copy()
+		opt_conf['prefix'] = 'Execution'
+		all_opts[opt] = opt_conf
+
+	# Process global output options
+	for opt in output_opts:
+		opt_conf = output_opts[opt].copy()
+		opt_conf['prefix'] = 'Output'
+		all_opts[opt] = opt_conf
+
+	# Process config options
+	# a.k.a:
+	# - default YAML config options, defined in default_options: key in the runner YAML config
+	# - new options defined in options: key in the runner YAML config
+	config_opts_defaults = config.default_options.toDict()
+	config_opts = config.options.toDict()
+	for k, v in config_opts.items():
+		all_opts[k] = v
+		all_opts[k]['prefix'] = f'{config.type}'
+
+	def find_same_opts(node, nodes, opt_name, check_class_opts=False):
+		"""Find options with the same name that are defined in other nodes of the same type."""
+		same_opts = []
+		for _ in nodes:
+			if _.id == node.id or _.type != node.type:
+				continue
+			node_task = None
+			if check_class_opts:
+				node_task = Task.get_task_class(_.name)
+				if opt_name not in node_task.opts:
+					continue
+				opts_value = node_task.opts[opt_name]
+			else:
+				if opt_name not in _.opts:
+					continue
+				opts_value = _.opts[opt_name]
+			name_str = 'nodes' if not check_class_opts else 'tasks'
+			debug(f'[bold]{config.name}[/] -> [bold blue]{node.id}[/] -> [bold green]{opt_name}[/] found in other {name_str} [bold blue]{_.id}[/]', sub=f'cli.{config.name}.same', verbose=True)  # noqa: E501
+			same_opts.append({
+				'id': _.id,
+				'task_name': node_task.__name__ if node_task else None,
+				'name': _.name,
+				'value': opts_value,
+			})
+		if same_opts:
+			other_tasks = ", ".join([f'[bold yellow]{_["id"]}[/]' for _ in same_opts])
+			debug(f'[bold]{config.name}[/] -> [bold blue]{node.id}[/] -> [bold green]{opt_name}[/] found in {len(same_opts)} other {name_str}: {other_tasks}', sub=f'cli.{config.name}.same', verbose=True)  # noqa: E501
+		return same_opts
+
+	def process_node(node):
+		debug(f'[bold]{config.name}[/] -> [bold blue]{node.id}[/] ({node.type})', sub=f'cli.{config.name}')
+
+		if node.type not in ['task', 'workflow']:
+			return
+
+		# Process workflow options
+		# a.k.a the new options defined in options: key in the workflow YAML config;
+		if node.type == 'workflow':
+			for k, v in node.opts.items():
+				same_opts = find_same_opts(node, nodes, k)
+				conf = v.copy()
+				opt_name = k
+				conf['prefix'] = f'{node.type.capitalize()} {node.name}'
+				if len(same_opts) > 0:  # opt name conflict, change opt name
+					opt_name = f'{node.name}.{k}'
+					debug(f'[bold]{config.name}[/] -> [bold blue]{node.id}[/] -> [bold green]{k}[/] renamed to [bold green]{opt_name}[/] [dim red](duplicated)[/]', sub=f'cli.{config.name}')  # noqa: E501
+				all_opts[opt_name] = conf
+			return
+
+		# Process task options
+		# a.k.a task options defined in their respective task classes
+		cls = Task.get_task_class(node.name)
+		task_opts = cls.opts.copy()
+		task_opts_meta = getattr(cls, 'meta_opts', {}).copy()
+		task_opts_all = {**task_opts, **task_opts_meta}
+		node_opts = node.opts or {}
+		ancestor_opts_defaults = node.ancestor.default_opts or {}
+		node_id_str = get_short_id(node.id, config.name)
+
+		for k, v in task_opts_all.items():
+			conf = v.copy()
+			conf['prefix'] = f'Task {node.name}'
+			# Use explicit None checks to properly handle boolean False values
+			default_from_config = next(
+				(item for item in [node_opts.get(k), ancestor_opts_defaults.get(k), config_opts_defaults.get(k)]
+				 if item is not None),
+				None
+			)
+			opt_name = k
+			same_opts = find_same_opts(node, nodes, k)
+
+			# Found a default in YAML config, either in task options, or workflow options, or config options
+			if default_from_config is not None:
+				conf['required'] = False
+				conf['default'] = default_from_config
+				conf['default_from'] = node_id_str
+				if node_opts.get(k) is not None:
+					conf['default_from'] = node_id_str
+					conf['prefix'] = 'Config'
+				elif ancestor_opts_defaults.get(k) is not None:
+					conf['default_from'] = get_short_id(node.ancestor.id, config.name)
+					conf['prefix'] = f'{node.ancestor.type.capitalize()} {node.ancestor.name}'
+				elif config_opts_defaults.get(k) is not None:
+					conf['default_from'] = config.name
+					conf['prefix'] = 'Config'
+				mapped_value = cls.opt_value_map.get(opt_name)
+				if mapped_value:
+					if callable(mapped_value):
+						default_from_config = mapped_value(default_from_config)
+					else:
+						default_from_config = mapped_value
+				conf['default'] = default_from_config
+				# Check for same opts in both config and class definitions to determine if we need to rename
+				same_opts_class = find_same_opts(node, nodes, k, check_class_opts=True)
+				if len(same_opts) > 0 or len(same_opts_class) > 0 or k in task_opts_meta:  # change opt name to avoid conflict
+					conf['prefix'] = 'Config'
+					opt_name = f'{conf["default_from"]}.{k}'
+					debug(f'[bold]{config.name}[/] -> [bold blue]{node.id}[/] -> [bold green]{k}[/] renamed to [bold green]{opt_name}[/] [dim red](default set in config)[/]', sub=f'cli.{config.name}')  # noqa: E501
+
+			# Standard meta options like rate_limit, delay, proxy, etc...
+			elif k in task_opts_meta:
+				conf['prefix'] = 'Meta'
+				debug(f'[bold]{config.name}[/] -> [bold blue]{node.id}[/] -> [bold green]{k}[/] changed prefix to [bold cyan]Meta[/]', sub=f'cli.{config.name}')  # noqa: E501
+
+			# Task-specific options
+			elif k in task_opts:
+				same_opts = find_same_opts(node, nodes, k, check_class_opts=True)
+				if len(same_opts) > 0:
+					# Check if any node has this option explicitly set in config
+					# If so, skip adding shared version as those nodes will have their own prefixed versions
+					same_opt_ids = [so['id'] for so in same_opts]
+					relevant_nodes = [node] + [n for n in nodes if n.id in same_opt_ids]
+					# debug(f'relevant nodes: {[n.name for n in relevant_nodes]}', sub=f'cli.{config.name}')
+					has_config_override = False
+					for node_to_check in relevant_nodes:
+						if hasattr(node_to_check.opts, 'get'):
+							if node_to_check.opts.get(k) is not None:
+								has_config_override = True
+								# debug(f'has config override: {has_config_override}: {node_to_check.opts.get(k)}', sub=f'cli.{config.name}')
+								break
+						elif k in node_to_check.opts:
+							has_config_override = True
+							break
+
+					if not has_config_override:
+						applies_to = set([node.name] + [_['name'] for _ in same_opts])
+						conf['applies_to'] = applies_to
+						conf['prefix'] = 'Shared task'
+						debug(f'[bold]{config.name}[/] -> [bold blue]{node.id}[/] -> [bold green]{k}[/] changed prefix to [bold cyan]Common[/] [dim red](duplicated {len(same_opts)} times)[/]', sub=f'cli.{config.name}')  # noqa: E501
+					else:
+						# Skip this option as it will be handled by the config override logic
+						debug(f'[bold]{config.name}[/] -> [bold blue]{node.id}[/] -> [bold green]{k}[/] skipped [dim red](has config override)[/]', sub=f'cli.{config.name}')  # noqa: E501
+						opt_name = f'{node.name}-{k}'
+						conf['applies_to'] = set([node.name])
+						conf['prefix'] = 'Config'
+						# continue
+			else:
+				raise ValueError(f'Unknown option {k} for task {node.id}')
+			all_opts[opt_name] = conf
+
+	walk_runner_tree(tree, process_node)
+
+	# Normalize all options
+	debug('[bold yellow3]All opts processed. Showing defaults:[/]', sub=f'cli.{config.name}')
+	normalized_opts = OrderedDict({})
+	for k, v in all_opts.items():
+		v['reverse'] = False
+		v['show_default'] = True
+		default_from = v.get('default_from')
+		default = v.get('default', False)
+		if isinstance(default, bool) and default is True:
+			v['reverse'] = True
+		if type_mapping and 'type' in v:
+			v['type'] = type_mapping.get(v['type'], str)
+		short = v.get('short')
+		k = k.replace('.', '-').replace('_', '-').replace('/', '-')
+		from_str = default_from.replace('.', '-').replace('_', '-').replace('/', '-') if default_from else None
+		if not default_from or from_str not in k:
+			v['short'] = short if short else None
+		else:
+			v['short'] = f'{from_str}-{short}' if short else None
+		debug(f'\t[bold]{k}[/] -> [bold green]{v.get("default", "N/A")}[/] [dim red](default from {v.get("default_from", "N/A")})[/]', sub=f'cli.{config.name}')  # noqa: E501
+		normalized_opts[k] = v
+	return normalized_opts

secator/thread.py

@@ -0,0 +1,24 @@
+import threading
+
+from secator.output_types import Error
+
+
+class Thread(threading.Thread):
+	"""A thread that returns errors in their join() method as secator.output_types.Error."""
+
+	def __init__(self, *args, **kwargs):
+		super().__init__(*args, **kwargs)
+		self.error = None
+
+	def run(self):
+		try:
+			if hasattr(self, '_target'):
+				self._target(*self._args, **self._kwargs)
+		except Exception as e:
+			self.error = Error.from_exception(e)
+
+	def join(self, *args, **kwargs):
+		super().join(*args, **kwargs)
+		if self.error:
+			return self.error
+		return None

secator/tree.py

@@ -0,0 +1,196 @@
+from typing import List, Optional, Union
+from secator.template import TemplateLoader
+from dotmap import DotMap
+
+
+DEFAULT_RENDER_OPTS = {
+	'group': lambda x: f"[dim]group {x.name.split('/')[-1] if '/' in x.name else ''}[/]",
+	'task': lambda x: f"[bold gold3]:wrench: {x.name}[/]",
+	'workflow': lambda x: f"[bold dark_orange3]:gear: {x.name}[/]",
+	'scan': lambda x: f"[bold red]:magnifying_glass_tilted_left: {x.name}[/]",
+	'condition': lambda x: f"[dim cyan]# if {x}[/]" if x else ''
+}
+
+
+class TaskNode:
+	"""Represents a node in the workflow/scan task tree."""
+	def __init__(self, name: str, type_: str, id: str, opts: Optional[dict] = None, default_opts: Optional[dict] = None, condition: Optional[str] = None, description: Optional[str] = None, parent=None, ancestor=None):  # noqa: E501
+		self.name = name
+		self.type = type_
+		self.id = id
+		self.opts = opts or {}
+		self.default_opts = default_opts or {}
+		self.description = description
+		self.condition = condition
+		self.children: List[TaskNode] = []
+		self.parent = parent
+		self.ancestor = ancestor
+
+	def add_child(self, child: 'TaskNode') -> None:
+		"""Add a child node to this node."""
+		self.children.append(child)
+
+	def remove(self):
+		"""Remove this node from its parent."""
+		if self.parent:
+			self.parent.children.remove(self)
+
+	def __str__(self) -> str:
+		"""String representation with condition if present."""
+		if self.condition:
+			return f"{self.name} # if {self.condition}"
+		return self.name
+
+
+class RunnerTree:
+	"""Represents a tree of workflow/scan tasks."""
+	def __init__(self, name: str, type_: str, render_opts: Optional[dict] = DEFAULT_RENDER_OPTS):
+		self.name = name
+		self.type = type_
+		self.root_nodes: List[TaskNode] = []
+		self.render_opts = render_opts
+
+	def add_root_node(self, node: TaskNode) -> None:
+		"""Add a root-level node to the tree."""
+		self.root_nodes.append(node)
+
+	def render_tree(self) -> str:
+		"""Render the tree as a console-friendly string."""
+		lines = []
+		for node in self.root_nodes:
+			node_str = self.render_opts.get(node.type, lambda x: str(x))(node)
+			condition_str = self.render_opts.get('condition', lambda x: str(x) if x else '')(node.condition)
+			if condition_str:
+				node_str = f"{node_str} {condition_str}"
+			lines.append(node_str)
+			self._render_children(node, "", lines)
+		return "\n".join(lines)
+
+	def _render_children(self, node: TaskNode, prefix: str, lines: List[str]) -> None:
+		"""Helper method to recursively render child nodes."""
+		children_count = len(node.children)
+		for i, child in enumerate(node.children):
+			is_last = i == children_count - 1
+			branch = "└─ " if is_last else "├─ "
+			child_str = self.render_opts.get(child.type, lambda x: str(x))
+			condition_str = self.render_opts.get('condition', lambda x: str(x) if x else '')(child.condition)
+			render_str = f"{prefix}{branch}{child_str(child)}"
+			if child.description:
+				render_str += f" - [dim]{child.description}[/]"
+			if condition_str:
+				render_str += f" {condition_str}"
+			lines.append(render_str)
+			if child.children:
+				new_prefix = prefix + ("   " if is_last else "│  ")
+				self._render_children(child, new_prefix, lines)
+
+	def get_subtree(self, node: TaskNode) -> 'RunnerTree':
+		"""Get the subtree of this node."""
+		subtree = RunnerTree(node.name, node.type)
+		for child in node.children:
+			subtree.add_root_node(child)
+		return subtree
+
+
+def build_runner_tree(config: DotMap, condition: Optional[str] = None, parent: Optional[TaskNode] = None, ancestor: Optional[TaskNode] = None) -> Union[RunnerTree, str]:  # noqa: E501
+	"""
+	Build a tree representation from a runner config.
+
+	Args:
+		config (DotMap): The runner config.
+
+	Returns:
+		A RunnerTree object or an error message string
+	"""
+	tree = RunnerTree(config.name, config.type)
+
+	if config.type == 'workflow':
+		root_node = TaskNode(config.name, 'workflow', config.name, opts=config.options, default_opts=config.default_options, condition=condition, parent=parent, ancestor=ancestor)  # noqa: E501
+		tree.add_root_node(root_node)
+
+		# Add tasks to the tree
+		for task_name, task_details in config.tasks.items():
+			id = f'{config.name}.{task_name}'
+			if task_name.startswith('_group'):
+				group_node = TaskNode(task_name, 'group', id, parent=root_node, ancestor=root_node)
+				root_node.add_child(group_node)
+				for subtask_name, subtask_details in task_details.items():
+					subtask_details = subtask_details or {}
+					id = f'{config.name}.{subtask_name}'
+					condition = subtask_details.get('if')
+					description = subtask_details.get('description')
+					subtask_node = TaskNode(subtask_name, 'task', id, opts=subtask_details, condition=condition, description=description, parent=group_node, ancestor=root_node)  # noqa: E501
+					group_node.add_child(subtask_node)
+			else:
+				condition = task_details.get('if') if task_details else None
+				description = task_details.get('description') if task_details else None
+				task_node = TaskNode(task_name, 'task', id, opts=task_details, condition=condition, description=description, parent=root_node, ancestor=root_node)  # noqa: E501
+				root_node.add_child(task_node)
+
+	elif config.type == 'scan':
+		id = f'{config.name}'
+		root_node = TaskNode(config.name, 'scan', id, opts=config.options, parent=parent)
+		tree.add_root_node(root_node)
+
+		# Add workflows to the tree
+		for workflow_name, workflow_details in config.workflows.items():
+			id = f'{config.name}.{workflow_name}'
+			condition = workflow_details.get('if') if isinstance(workflow_details, dict) else None
+			split_name = workflow_name.split('/')
+			wf_name = split_name[0]
+			wf_config = TemplateLoader(name=f'workflow/{wf_name}')
+			wf_config.name = workflow_name
+			wf_tree = build_runner_tree(wf_config, condition, parent=root_node, ancestor=root_node)
+			if isinstance(wf_tree, RunnerTree):
+				for wf_root_node in wf_tree.root_nodes:
+					root_node.add_child(wf_root_node)
+
+	elif config.type == 'task':
+		root_node = TaskNode(config.name, 'task', config.name, opts={}, parent=parent, ancestor=ancestor)
+		tree.add_root_node(root_node)
+
+	return tree
+
+
+def walk_runner_tree(tree: RunnerTree, visit_func):
+	"""
+	Walk the RunnerTree and visit each node.
+
+	Args:
+		tree (RunnerTree): The RunnerTree to walk.
+		visit_func (function): A function to call on each node.
+	"""
+	for root_node in tree.root_nodes:
+		_walk_node(root_node, visit_func)
+
+
+def _walk_node(node: TaskNode, visit_func):
+	"""
+	Recursively walk the node and its children.
+
+	Args:
+		node (TaskNode): The node to walk.
+		visit_func (function): A function to call on each node.
+	"""
+	visit_func(node)
+	for child in node.children:
+		_walk_node(child, visit_func)
+
+
+def get_flat_node_list(tree: RunnerTree) -> List[TaskNode]:
+	"""
+	Get the flat list of all nodes in the RunnerTree.
+
+	Args:
+		tree (RunnerTree): The RunnerTree to traverse.
+
+	Returns:
+		List[TaskNode]: The list of all nodes in the tree.
+	"""
+	nodes = []
+
+	def collect_node(node: TaskNode):
+		nodes.append(node)
+
+	walk_runner_tree(tree, collect_node)
+	return nodes