Open-source AI penetration testing tool to find and fix your app’s vulnerabilities.
Python agentsai-hackingai-penetration-testingai-pentestingai-securityartificial-intelligencebug-bountycode-qualityctf-toolscybersecuritycybersecurity-toolsethical-hackinghackingllm-securityoffensive-securitypenetration-testingpentesting-toolsred-teamingsecuritysecurity-automation
Add TUI renderers for the seven previously-unstyled tools
0xallamd3ab3f836b1c
diff --git a/strix/interface/tui/renderers/__init__.py b/strix/interface/tui/renderers/__init__.pyindex 51e76d0e..75f60d7b 100644--- a/strix/interface/tui/renderers/__init__.py+++ b/strix/interface/tui/renderers/__init__.py@@ -1,9 +1,12 @@from . import (agents_graph_renderer,+ filesystem_renderer,finish_renderer,+ load_skill_renderer,notes_renderer,proxy_renderer,reporting_renderer,+ shell_renderer,thinking_renderer,todo_renderer,web_search_renderer,@@ -13,11 +16,14 @@ from .registry import render_tool_widget__all__ = ["agents_graph_renderer",+ "filesystem_renderer","finish_renderer",+ "load_skill_renderer","notes_renderer","proxy_renderer","render_tool_widget","reporting_renderer",+ "shell_renderer","thinking_renderer","todo_renderer","web_search_renderer",diff --git a/strix/interface/tui/renderers/filesystem_renderer.py b/strix/interface/tui/renderers/filesystem_renderer.pynew file mode 100644index 00000000..341addcb--- /dev/null+++ b/strix/interface/tui/renderers/filesystem_renderer.py@@ -0,0 +1,266 @@+from __future__ import annotations++import json+from functools import cache+from typing import Any, ClassVar++from pygments.lexers import get_lexer_by_name, get_lexer_for_filename+from pygments.styles import get_style_by_name+from pygments.util import ClassNotFound+from rich.text import Text+from textual.widgets import Static++from .base_renderer import BaseToolRenderer+from .registry import register_tool_renderer+++_ADD_FILE = "*** Add File: "+_DELETE_FILE = "*** Delete File: "+_UPDATE_FILE = "*** Update File: "+_BEGIN_PATCH = "*** Begin Patch"+_END_PATCH = "*** End Patch"++_VIEW_IMAGE_ERROR_PREFIXES = (+ "image path ",+ "unable to read image",+ "manifest path",+ "exceeded the allowed size",+)+++@cache+def _get_style_colors() -> dict[Any, str]:+ style = get_style_by_name("native")+ return {token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]}+++def _get_lexer_for_file(path: str) -> Any:+ try:+ return get_lexer_for_filename(path)+ except ClassNotFound:+ return get_lexer_by_name("text")+++def _get_token_color(token_type: Any) -> str | None:+ colors = _get_style_colors()+ while token_type:+ if token_type in colors:+ return colors[token_type]+ token_type = token_type.parent+ return None+++def _highlight_code(code: str, path: str) -> Text:+ lexer = _get_lexer_for_file(path)+ text = Text()+ for token_type, token_value in lexer.get_tokens(code):+ if not token_value:+ continue+ color = _get_token_color(token_type)+ text.append(token_value, style=color)+ return text+++def _extract_patch_text(args: dict[str, Any]) -> str:+ """apply_patch input arrives as either {"patch": text} or raw text in+ the "input" field, depending on whether the tool is wrapped as a+ chat-completions FunctionTool or routed through as a CustomTool.+ """+ raw = args.get("patch")+ if isinstance(raw, str):+ return raw+ if isinstance(raw, dict):+ inner = raw.get("patch")+ if isinstance(inner, str):+ return inner+ fallback = args.get("input") if isinstance(args, dict) else None+ if isinstance(fallback, str):+ return fallback+ return ""+++def _parse_patch_operations(+ patch_text: str,+) -> list[tuple[str, str, list[str], list[str]]]:+ """Return [(kind, path, old_lines, new_lines), ...] for each file op."""+ ops: list[tuple[str, str, list[str], list[str]]] = []+ current_kind: str | None = None+ current_path: str | None = None+ old_lines: list[str] = []+ new_lines: list[str] = []++ def flush() -> None:+ nonlocal current_kind, current_path, old_lines, new_lines+ if current_kind and current_path is not None:+ ops.append((current_kind, current_path, old_lines, new_lines))+ current_kind = None+ current_path = None+ old_lines = []+ new_lines = []++ for line in patch_text.splitlines():+ if line in (_BEGIN_PATCH, _END_PATCH):+ continue+ if line.startswith(_ADD_FILE):+ flush()+ current_kind = "add"+ current_path = line[len(_ADD_FILE) :].strip()+ elif line.startswith(_UPDATE_FILE):+ flush()+ current_kind = "update"+ current_path = line[len(_UPDATE_FILE) :].strip()+ elif line.startswith(_DELETE_FILE):+ flush()+ current_kind = "delete"+ current_path = line[len(_DELETE_FILE) :].strip()+ elif current_kind == "update":+ if line.startswith("@@"):+ continue+ if line.startswith("-") and not line.startswith("---"):+ old_lines.append(line[1:])+ elif line.startswith("+") and not line.startswith("+++"):+ new_lines.append(line[1:])+ elif current_kind == "add":+ if line.startswith("+"):+ new_lines.append(line[1:])+ elif line.strip():+ new_lines.append(line)+ flush()+ return ops+++_OP_LABEL = {+ "add": "create",+ "update": "edit",+ "delete": "delete",+}+++def _render_operation(text: Text, kind: str, path: str, old: list[str], new: list[str]) -> None:+ label = _OP_LABEL.get(kind, "file")++ text.append("◇ ", style="#10b981")+ text.append(label, style="dim")++ if path:+ path_display = path[-60:] if len(path) > 60 else path+ text.append(" ")+ text.append(path_display, style="dim")++ if kind == "update":+ if old:+ highlighted_old = _highlight_code("\n".join(old), path)+ for line in highlighted_old.plain.split("\n"):+ text.append("\n")+ text.append("-", style="#ef4444")+ text.append(" ")+ text.append(line)+ if new:+ highlighted_new = _highlight_code("\n".join(new), path)+ for line in highlighted_new.plain.split("\n"):+ text.append("\n")+ text.append("+", style="#22c55e")+ text.append(" ")+ text.append(line)+ elif kind == "add" and new:+ text.append("\n")+ text.append_text(_highlight_code("\n".join(new), path))+++@register_tool_renderer+class ApplyPatchRenderer(BaseToolRenderer):+ tool_name: ClassVar[str] = "apply_patch"+ css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]++ @classmethod+ def render(cls, tool_data: dict[str, Any]) -> Static:+ args = tool_data.get("args", {})+ result = tool_data.get("result")+ status = tool_data.get("status", "completed")++ patch_text = _extract_patch_text(args)+ ops = _parse_patch_operations(patch_text)++ text = Text()++ if not ops:+ text.append("◇ ", style="#10b981")+ text.append("patch", style="dim")+ if isinstance(result, str) and result.strip():+ text.append("\n ")+ text.append(result.strip(), style="dim")+ elif not result:+ text.append(" ")+ text.append("Processing...", style="dim")+ return Static(text, classes=cls.get_css_classes(status))++ for i, (kind, path, old, new) in enumerate(ops):+ if i > 0:+ text.append("\n")+ _render_operation(text, kind, path, old, new)++ if status == "failed" and isinstance(result, str) and result.strip():+ text.append("\n ")+ text.append(result.strip(), style="#ef4444")++ return Static(text, classes=cls.get_css_classes(status))+++def _is_image_success(result: Any) -> bool:+ if isinstance(result, dict) and result.get("type") == "image":+ return True+ if isinstance(result, str):+ stripped = result.lstrip()+ if stripped.startswith("data:image/"):+ return True+ try:+ obj = json.loads(stripped)+ except (TypeError, ValueError):+ return False+ return isinstance(obj, dict) and obj.get("type") == "image"+ return False+++def _image_error_text(result: Any) -> str | None:+ if not isinstance(result, str):+ return None+ stripped = result.strip()+ if not stripped:+ return None+ lower = stripped.lower()+ if lower.startswith(_VIEW_IMAGE_ERROR_PREFIXES) or "not a supported image" in lower:+ return stripped+ return None+++@register_tool_renderer+class ViewImageRenderer(BaseToolRenderer):+ tool_name: ClassVar[str] = "view_image"+ css_classes: ClassVar[list[str]] = ["tool-call", "file-edit-tool"]++ @classmethod+ def render(cls, tool_data: dict[str, Any]) -> Static:+ args = tool_data.get("args", {})+ result = tool_data.get("result")+ status = tool_data.get("status", "completed")++ path = str(args.get("path", "")).strip()++ text = Text()+ text.append("◇ ", style="#10b981")+ text.append("view image", style="dim")++ if path:+ path_display = path[-60:] if len(path) > 60 else path+ text.append(" ")+ text.append(path_display, style="dim")++ err = _image_error_text(result)+ if err is not None:+ text.append("\n ")+ text.append(err, style="#ef4444")+ elif _is_image_success(result):+ text.append(" ")+ text.append("✓", style="#22c55e")++ return Static(text, classes=cls.get_css_classes(status))diff --git a/strix/interface/tui/renderers/load_skill_renderer.py b/strix/interface/tui/renderers/load_skill_renderer.pynew file mode 100644index 00000000..52cde4be--- /dev/null+++ b/strix/interface/tui/renderers/load_skill_renderer.py@@ -0,0 +1,37 @@+from typing import Any, ClassVar++from rich.text import Text+from textual.widgets import Static++from .base_renderer import BaseToolRenderer+from .registry import register_tool_renderer+++@register_tool_renderer+class LoadSkillRenderer(BaseToolRenderer):+ tool_name: ClassVar[str] = "load_skill"+ css_classes: ClassVar[list[str]] = ["tool-call", "load-skill-tool"]++ @classmethod+ def render(cls, tool_data: dict[str, Any]) -> Static:+ args = tool_data.get("args", {})+ status = tool_data.get("status", "completed")++ raw_skills = args.get("skills", "")+ if isinstance(raw_skills, list):+ requested = ", ".join(str(s) for s in raw_skills)+ else:+ requested = str(raw_skills)++ text = Text()+ text.append("◇ ", style="#10b981")+ text.append("loading skill", style="dim")++ if requested:+ text.append(" ")+ text.append(requested, style="#10b981")+ elif not tool_data.get("result"):+ text.append("\n ")+ text.append("Loading...", style="dim")++ return Static(text, classes=cls.get_css_classes(status))diff --git a/strix/interface/tui/renderers/proxy_renderer.py b/strix/interface/tui/renderers/proxy_renderer.pyindex fe48b715..94bf3c95 100644--- a/strix/interface/tui/renderers/proxy_renderer.py+++ b/strix/interface/tui/renderers/proxy_renderer.py@@ -293,6 +293,155 @@ class RepeatRequestRenderer(BaseToolRenderer):return Static(text, classes=css_classes)+@register_tool_renderer+class ListSitemapRenderer(BaseToolRenderer):+ tool_name: ClassVar[str] = "list_sitemap"+ css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]++ @classmethod+ def render(cls, tool_data: dict[str, Any]) -> Static: # noqa: PLR0912, PLR0915+ args = tool_data.get("args", {})+ result = tool_data.get("result")+ status = tool_data.get("status", "running")++ parent_id = args.get("parent_id")+ scope_id = args.get("scope_id")+ depth = args.get("depth")++ text = Text()+ text.append(PROXY_ICON, style="dim")+ text.append(" listing sitemap", style="#06b6d4")++ if parent_id:+ text.append(f" under #{_truncate(str(parent_id), 20)}", style="dim")++ meta_parts = []+ if scope_id and isinstance(scope_id, str):+ meta_parts.append(f"scope:{scope_id[:8]}")+ if depth and depth != "DIRECT":+ meta_parts.append(depth.lower())+ if meta_parts:+ text.append(f" ({', '.join(meta_parts)})", style="dim")++ if status == "completed" and isinstance(result, dict):+ if "error" in result:+ text.append(f" error: {_sanitize(str(result['error']), 150)}", style="#ef4444")+ else:+ total = result.get("total_count", 0)+ entries = result.get("entries", [])++ text.append(f" [{total} entries]", style="dim")++ if entries and isinstance(entries, list):+ text.append("\n")+ for i, entry in enumerate(entries[:MAX_REQUESTS_DISPLAY]):+ if not isinstance(entry, dict):+ continue+ kind = entry.get("kind") or "?"+ label = entry.get("label") or "?"+ has_children = entry.get("has_descendants", False)+ req = entry.get("request") or {}++ kind_style = {+ "DOMAIN": "#f59e0b",+ "DIRECTORY": "#3b82f6",+ "REQUEST": "#22c55e",+ }.get(kind, "dim")++ text.append(" ")+ kind_abbr = kind[:3] if isinstance(kind, str) else "?"+ text.append(f"{kind_abbr:3}", style=kind_style)+ text.append(f" {_truncate(label, 150)}", style="dim")++ if req:+ method = req.get("method", "")+ code = req.get("status_code")+ if method:+ text.append(f" {method}", style="#a78bfa")+ if code:+ text.append(f" {code}", style=_status_style(code))++ if has_children:+ text.append(" +", style="dim italic")++ if i < min(len(entries), MAX_REQUESTS_DISPLAY) - 1:+ text.append("\n")++ if len(entries) > MAX_REQUESTS_DISPLAY:+ text.append("\n")+ text.append(+ f" ... +{len(entries) - MAX_REQUESTS_DISPLAY} more", style="dim italic"+ )++ css_classes = cls.get_css_classes(status)+ return Static(text, classes=css_classes)+++@register_tool_renderer+class ViewSitemapEntryRenderer(BaseToolRenderer):+ tool_name: ClassVar[str] = "view_sitemap_entry"+ css_classes: ClassVar[list[str]] = ["tool-call", "proxy-tool"]++ @classmethod+ def render(cls, tool_data: dict[str, Any]) -> Static: # noqa: PLR0912+ args = tool_data.get("args", {})+ result = tool_data.get("result")+ status = tool_data.get("status", "running")++ entry_id = args.get("entry_id", "")++ text = Text()+ text.append(PROXY_ICON, style="dim")+ text.append(" viewing sitemap", style="#06b6d4")++ if entry_id:+ text.append(f" #{_truncate(str(entry_id), 20)}", style="dim")++ if status == "completed" and isinstance(result, dict):+ if "error" in result:+ text.append(f" error: {_sanitize(str(result['error']), 150)}", style="#ef4444")+ elif "entry" in result:+ entry = result.get("entry") or {}+ if not isinstance(entry, dict):+ entry = {}+ kind = entry.get("kind", "")+ label = entry.get("label", "")+ related = entry.get("related_requests") or {}+ related_reqs = related.get("requests", []) if isinstance(related, dict) else []+ total_related = related.get("total_count", 0) if isinstance(related, dict) else 0++ if kind and label:+ text.append(f" {kind}: {_truncate(label, 120)}", style="dim")++ if total_related:+ text.append(f" [{total_related} requests]", style="dim")++ if related_reqs and isinstance(related_reqs, list):+ text.append("\n")+ for i, req in enumerate(related_reqs[:10]):+ if not isinstance(req, dict):+ continue+ method = req.get("method", "?")+ path = req.get("path", "/")+ code = req.get("status_code")++ text.append(" ")+ text.append(f"{method:6}", style="#a78bfa")+ text.append(f" {_truncate(path, 180)}", style="dim")+ if code:+ text.append(f" {code}", style=_status_style(code))++ if i < min(len(related_reqs), 10) - 1:+ text.append("\n")++ if len(related_reqs) > 10:+ text.append("\n")+ text.append(f" ... +{len(related_reqs) - 10} more", style="dim italic")++ css_classes = cls.get_css_classes(status)+ return Static(text, classes=css_classes)++@register_tool_rendererclass ScopeRulesRenderer(BaseToolRenderer):tool_name: ClassVar[str] = "scope_rules"diff --git a/strix/interface/tui/renderers/shell_renderer.py b/strix/interface/tui/renderers/shell_renderer.pynew file mode 100644index 00000000..d15c0c58--- /dev/null+++ b/strix/interface/tui/renderers/shell_renderer.py@@ -0,0 +1,262 @@+import re+from functools import cache+from typing import Any, ClassVar++from pygments.lexers import get_lexer_by_name+from pygments.styles import get_style_by_name+from rich.text import Text+from textual.widgets import Static++from .base_renderer import BaseToolRenderer+from .registry import register_tool_renderer+++MAX_OUTPUT_LINES = 50+MAX_LINE_LENGTH = 200++STRIP_PATTERNS = [+ r"^Chunk ID: [0-9a-f]+\s*$",+ r"^Wall time: [\d.]+ seconds\s*$",+ r"^Process exited with code -?\d+\s*$",+ r"^Process running with session ID \d+\s*$",+ r"^Original token count: \d+\s*$",+]++_EXIT_RE = re.compile(r"Process exited with code (-?\d+)")+_SESSION_RE = re.compile(r"Process running with session ID (\d+)")+_OUTPUT_HEADER = "\nOutput:\n"+++@cache+def _get_style_colors() -> dict[Any, str]:+ style = get_style_by_name("native")+ return {token: f"#{style_def['color']}" for token, style_def in style if style_def["color"]}+++def _parse_sdk_shell_result(result: Any) -> dict[str, Any]:+ """Translate the SDK's terminal-output string into the dict shape the+ renderer's `_append_output` helper expects.++ The SDK returns a header-prefixed string ending with `Output:\\n<actual>`.+ We extract `content`, `exit_code`, and `session_id`; anything else (or a+ non-string result) flows through unchanged so renderers can handle errors.+ """+ if isinstance(result, dict):+ return result+ if not isinstance(result, str):+ return {"content": "" if result is None else str(result)}++ exit_match = _EXIT_RE.search(result)+ session_match = _SESSION_RE.search(result)+ idx = result.find(_OUTPUT_HEADER)+ content = result[idx + len(_OUTPUT_HEADER) :] if idx >= 0 else result++ parsed: dict[str, Any] = {"content": content}+ if exit_match:+ parsed["exit_code"] = int(exit_match.group(1))+ if session_match:+ parsed["session_id"] = int(session_match.group(1))+ return parsed+++def _truncate_line(line: str) -> str:+ clean_line = re.sub(r"\x1b\[[0-9;]*m", "", line)+ if len(clean_line) > MAX_LINE_LENGTH:+ return line[: MAX_LINE_LENGTH - 3] + "..."+ return line+++def _clean_output(output: str) -> str:+ cleaned = output+ for pattern in STRIP_PATTERNS:+ cleaned = re.sub(pattern, "", cleaned, flags=re.MULTILINE)++ if cleaned.strip():+ lines = cleaned.splitlines()+ filtered_lines: list[str] = []+ for line in lines:+ if not filtered_lines and not line.strip():+ continue+ if line.strip() == "Output:":+ continue+ filtered_lines.append(line)+ while filtered_lines and not filtered_lines[-1].strip():+ filtered_lines.pop()+ cleaned = "\n".join(filtered_lines)++ return cleaned.strip()+++def _format_output(output: str) -> Text:+ text = Text()+ lines = output.splitlines()+ total_lines = len(lines)++ head_count = MAX_OUTPUT_LINES // 2+ tail_count = MAX_OUTPUT_LINES - head_count - 1++ if total_lines <= MAX_OUTPUT_LINES:+ display_lines = lines+ truncated = False+ hidden_count = 0+ else:+ display_lines = lines[:head_count]+ truncated = True+ hidden_count = total_lines - head_count - tail_count++ for i, line in enumerate(display_lines):+ text.append(" ")+ text.append(_truncate_line(line), style="dim")+ if i < len(display_lines) - 1 or truncated:+ text.append("\n")++ if truncated:+ text.append(f" ... {hidden_count} lines truncated ...", style="dim italic")+ text.append("\n")+ tail_lines = lines[-tail_count:]+ for i, line in enumerate(tail_lines):+ text.append(" ")+ text.append(_truncate_line(line), style="dim")+ if i < len(tail_lines) - 1:+ text.append("\n")++ return text+++def _get_token_color(token_type: Any) -> str | None:+ colors = _get_style_colors()+ while token_type:+ if token_type in colors:+ return colors[token_type]+ token_type = token_type.parent+ return None+++def _highlight_bash(code: str) -> Text:+ lexer = get_lexer_by_name("bash")+ text = Text()+ for token_type, token_value in lexer.get_tokens(code):+ if not token_value:+ continue+ color = _get_token_color(token_type)+ text.append(token_value, style=color)+ return text+++def _append_output(text: Text, parsed: dict[str, Any], tool_status: str) -> None:+ raw_output = parsed.get("content", "") or ""+ output = _clean_output(raw_output) if isinstance(raw_output, str) else ""+ exit_code = parsed.get("exit_code")++ if tool_status == "running":+ if output:+ text.append("\n")+ text.append_text(_format_output(output))+ return++ if not output:+ if exit_code is not None and exit_code != 0:+ text.append("\n")+ text.append(f" exit {exit_code}", style="dim #ef4444")+ return++ text.append("\n")+ text.append_text(_format_output(output))++ if exit_code is not None and exit_code != 0:+ text.append("\n")+ text.append(f" exit {exit_code}", style="dim #ef4444")+++def _build_terminal_content(+ *,+ prompt: str,+ prompt_style: str,+ command: str,+ parsed_result: dict[str, Any] | None,+ tool_status: str,+ meta: str | None = None,+) -> Text:+ text = Text()+ text.append(">_", style="dim")+ text.append(" ")++ if not command.strip():+ text.append("getting logs...", style="dim")+ else:+ text.append(prompt, style=prompt_style)+ text.append(" ")+ text.append_text(_highlight_bash(command))++ if meta:+ text.append(f" {meta}", style="dim")++ if parsed_result is not None:+ _append_output(text, parsed_result, tool_status)++ return text+++@register_tool_renderer+class ExecCommandRenderer(BaseToolRenderer):+ tool_name: ClassVar[str] = "exec_command"+ css_classes: ClassVar[list[str]] = ["tool-call", "terminal-tool"]++ @classmethod+ def render(cls, tool_data: dict[str, Any]) -> Static:+ args = tool_data.get("args", {})+ status = tool_data.get("status", "unknown")+ result = tool_data.get("result")++ cmd = str(args.get("cmd", ""))+ workdir = args.get("workdir")+ tty = bool(args.get("tty"))++ meta_parts: list[str] = []+ if workdir:+ meta_parts.append(f"cwd:{workdir}")+ if tty:+ meta_parts.append("tty")+ meta = ", ".join(meta_parts) if meta_parts else None++ parsed = _parse_sdk_shell_result(result) if result is not None else None++ content = _build_terminal_content(+ prompt="$",+ prompt_style="#22c55e",+ command=cmd,+ parsed_result=parsed,+ tool_status=status,+ meta=meta,+ )++ return Static(content, classes=cls.get_css_classes(status))+++@register_tool_renderer+class WriteStdinRenderer(BaseToolRenderer):+ tool_name: ClassVar[str] = "write_stdin"+ css_classes: ClassVar[list[str]] = ["tool-call", "terminal-tool"]++ @classmethod+ def render(cls, tool_data: dict[str, Any]) -> Static:+ args = tool_data.get("args", {})+ status = tool_data.get("status", "unknown")+ result = tool_data.get("result")++ chars = str(args.get("chars", ""))+ session_id = args.get("session_id")+ meta = f"session #{session_id}" if session_id is not None else None++ parsed = _parse_sdk_shell_result(result) if result is not None else None++ content = _build_terminal_content(+ prompt=">>>",+ prompt_style="#3b82f6",+ command=chars,+ parsed_result=parsed,+ tool_status=status,+ meta=meta,+ )++ return Static(content, classes=cls.get_css_classes(status))