@ksl101/vulnreaper 0.1.0-beta.0 → 0.1.0-beta.1

package/README.md

@@ -95,9 +95,9 @@ vulnreaper --version
 | `vulnreaper logout` | Ferme la session locale |
 | `vulnreaper whoami [--json]` | Affiche licence, rôle, statut, permissions |
 | `vulnreaper admin license\|device\|audit …` | Administration des licences/appareils (rôle `admin`) |
-| `vulnreaper ui` | Menu interactif |
+| `vulnreaper ui` | Shell interactif (REPL conversationnel) |
 
-Sans commande, `vulnreaper` ouvre le menu interactif (`ui`).
+Sans commande, `vulnreaper` ouvre le shell interactif (`ui`).
 
 ---
 
@@ -142,7 +142,7 @@ définissent dans la configuration (`vulnreaper config show`).
 
 ```
 vulnreaper/                 paquet principal
-  cli/                  point d'entrée, menu interactif, tableaux/dashboard
+  cli/                  point d'entrée, shell interactif (REPL), thème + composants
   formats/              parseurs strings, AXML, DEX, ELF, métadonnées IL2CPP
   android/              import APK, modèle manifest, analyse dex/natif, adb
   unity/ il2cpp/        détection moteur + adaptateurs de dump
@@ -160,7 +160,7 @@ docs/                   architecture, règles, utilisation
 ## Tests
 
 ```bat
-python -m pytest tests/ -q      :: cœur Python (122 tests)
+python -m pytest tests/ -q      :: cœur Python + UI (164 tests)
 python tests/smoke.py           :: scan end-to-end d'un APK synthétique
 cd server && npm test           :: API de licence (11 tests, store mémoire)
 cd server && VULNREAPER_E2E=1 npm test   :: + E2E CLI ↔ API
@@ -181,6 +181,7 @@ prérequis : **[docs/TESTING.md](docs/TESTING.md)**.
 
 - [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) — conception et flux de données
 - [`docs/USAGE.md`](docs/USAGE.md) — prise en main et workflow bug-bounty
+- [`docs/UI.md`](docs/UI.md) — interface CLI/REPL (thème, composants, raccourcis)
 - [`docs/RULES.md`](docs/RULES.md) — packs de règles et écriture de règles
 - [`docs/BETA_TESTERS.md`](docs/BETA_TESTERS.md) — guide des testeurs bêta (npm, licence, gating)
 - [`docs/TESTING.md`](docs/TESTING.md) — stratégie et couverture des tests

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ksl101/vulnreaper",
-  "version": "0.1.0-beta.0",
+  "version": "0.1.0-beta.1",
   "description": "VulnReaper - authorised security auditing & bug-bounty CLI for Android/Unity/IL2CPP game packages",
   "keywords": [
     "security",

package/vendor/vulnreaper/__init__.py

@@ -1,23 +1,23 @@
-"""VulnReaper — Android game security research & bug-bounty automation platform.
-
-A modular, offline-first toolkit for analysing Android/Unity/IL2CPP game
-packages: APK/DEX/native/IL2CPP parsing, secret and misconfiguration scanning,
-endpoint discovery, and JSON/Markdown/HTML reporting.
-
-Design invariants
------------------
-* Standard library only (no third-party runtime dependencies).
-* Never fabricate results: a missing external tool is reported as ``missing``
-  and its pipeline stage is ``skipped`` — never simulated.
-* Windows-first, POSIX-compatible.
-"""
-from __future__ import annotations
-
-__all__ = ["__version__", "PRODUCT"]
-
-__version__ = "0.1.0-beta.0"
-PRODUCT = "VulnReaper"
-
-
-def version_string() -> str:
-    return f"{PRODUCT} {__version__} — Security Research Platform"
+"""VulnReaper — Android game security research & bug-bounty automation platform.
+
+A modular, offline-first toolkit for analysing Android/Unity/IL2CPP game
+packages: APK/DEX/native/IL2CPP parsing, secret and misconfiguration scanning,
+endpoint discovery, and JSON/Markdown/HTML reporting.
+
+Design invariants
+-----------------
+* Standard library only (no third-party runtime dependencies).
+* Never fabricate results: a missing external tool is reported as ``missing``
+  and its pipeline stage is ``skipped`` — never simulated.
+* Windows-first, POSIX-compatible.
+"""
+from __future__ import annotations
+
+__all__ = ["__version__", "PRODUCT"]
+
+__version__ = "0.1.0-beta.1"
+PRODUCT = "VulnReaper"
+
+
+def version_string() -> str:
+    return f"{PRODUCT} {__version__} — Security Research Platform"

package/vendor/vulnreaper/cli/__init__.py

@@ -1,4 +1,4 @@
 """Command-line interface."""
 from __future__ import annotations
 
-__all__ = ["app", "menu"]
+__all__ = ["app"]

package/vendor/vulnreaper/cli/app.py

@@ -28,6 +28,8 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--offline", action="store_true", help="use cached release information only")
     parser.add_argument("-v", "--verbose", action="store_true", help="verbose logging")
     parser.add_argument("-q", "--quiet", action="store_true", help="suppress console logs")
+    parser.add_argument("--debug", action="store_true",
+                        help="verbose console logging and full tracebacks")
 
     sub = parser.add_subparsers(dest="command")
 
@@ -104,7 +106,7 @@ def build_parser() -> argparse.ArgumentParser:
     p_aa.add_argument("--json", action="store_true")
 
     sub.add_parser("doctor", help="environment diagnostics")
-    sub.add_parser("ui", help="interactive menu")
+    sub.add_parser("ui", help="interactive shell (default)")
     return parser
 
 
@@ -117,7 +119,7 @@ def main(argv: list[str] | None = None) -> int:
     home = config.general.home or str(Config.home_dir())
     config.general.home = home
 
-    configure(home, verbose=args.verbose, quiet=args.quiet)
+    configure(home, verbose=args.verbose or args.debug, quiet=args.quiet)
     log = get_logger()
     console = make_console(color=config.output.color and not args.no_color)
 
@@ -160,20 +162,24 @@ def main(argv: list[str] | None = None) -> int:
         if command == "doctor":
             return _cmd_doctor(console, config, home)
         if command == "ui":
-            from .menu import run_menu
+            # The conversational shell: a fast splash, then a prompt.  Update
+            # checks are NOT run here (they used to print a table on every
+            # start); the shell reaches them on demand via /updates.
+            from .repl import run_repl
+            from .theme import Theme
             vulnreaper = VulnReaper(config, home=home)
             vulnreaper.offline = args.offline
-            try:
-                if config.tools.check_updates_on_start:
-                    _show_updates(console, vulnreaper, offline=args.offline)
-                return run_menu(vulnreaper, console)
-            finally:
-                vulnreaper.projects.close()
+            theme = Theme(color=config.output.color and not args.no_color)
+            return run_repl(vulnreaper, config, home, console, theme,
+                            offline=args.offline)
     except KeyboardInterrupt:
         console.print("\ninterrupted")
         return 130
     except Exception as exc:  # noqa: BLE001 - top-level guard
         log.exception("command failed")
+        if args.debug:
+            import traceback
+            traceback.print_exc()
         console.print(console.style(f"error: {type(exc).__name__}: {exc}", "red"))
         return 1
 

package/vendor/vulnreaper/cli/autocomplete.py

@@ -0,0 +1,50 @@
+"""Pure completion helpers.
+
+Kept free of any terminal I/O so they are trivially unit-testable.
+"""
+from __future__ import annotations
+
+
+def common_prefix(items: list[str]) -> str:
+    """Longest common prefix of ``items`` (empty when there is none)."""
+    if not items:
+        return ""
+    first, last = min(items), max(items)
+    i = 0
+    limit = min(len(first), len(last))
+    while i < limit and first[i] == last[i]:
+        i += 1
+    return first[:i]
+
+
+def current_token(buffer: str) -> str:
+    """The token under the cursor for completion purposes (first word here)."""
+    return buffer.lstrip().split(" ", 1)[0]
+
+
+def matches(buffer: str, names: list[str]) -> list[str]:
+    token = current_token(buffer)
+    if not token:
+        return []
+    return [name for name in names if name.startswith(token)]
+
+
+def complete(buffer: str, names: list[str]) -> tuple[str, list[str]]:
+    """Return ``(new_buffer, candidates)``.
+
+    * one candidate  -> the token is completed and a trailing space added
+    * many candidates -> extend to their common prefix when it is longer
+    * none           -> buffer unchanged
+    """
+    candidates = matches(buffer, names)
+    if not candidates:
+        return buffer, []
+    token = current_token(buffer)
+    if len(candidates) == 1:
+        rest = buffer.lstrip()[len(token):]
+        return candidates[0] + " " + rest.lstrip(), candidates
+    prefix = common_prefix(candidates)
+    if len(prefix) > len(token):
+        rest = buffer.lstrip()[len(token):]
+        return prefix + rest, candidates
+    return buffer, candidates

package/vendor/vulnreaper/cli/commands.py

@@ -0,0 +1,300 @@
+"""Slash-command registry for the conversational REPL.
+
+Every handler takes the live :class:`~vulnreaper.cli.repl.ReplSession` and the
+raw argument string, and returns an exit code (``0`` success).  Engine/licence
+imports are done lazily inside the handlers to keep import order simple and to
+avoid pulling the whole stack in for ``/help``.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+from ..findings.model import SEVERITIES
+from .intent import split_args
+
+
+@dataclass
+class Command:
+    name: str
+    summary: str
+    usage: str
+    handler: Callable | None = None
+    hidden: bool = False
+
+
+def _opt(tokens: list[str], *flags: str) -> str | None:
+    """Return the value following the first present flag."""
+    for i, token in enumerate(tokens):
+        if token in flags and i + 1 < len(tokens):
+            return tokens[i + 1]
+        for flag in flags:
+            if token.startswith(flag + "="):
+                return token.split("=", 1)[1]
+    return None
+
+
+def _positional(tokens: list[str]) -> list[str]:
+    out: list[str] = []
+    skip = False
+    for token in tokens:
+        if skip:
+            skip = False
+            continue
+        if token.startswith("-"):
+            if "=" not in token and token in ("--profile", "-p", "--project", "--run", "--severity", "-s", "--limit"):
+                skip = True
+            continue
+        out.append(token)
+    return out
+
+
+# ----------------------------------------------------------------- handlers
+def cmd_scan(session, args: str) -> int:
+    from .. import gating
+    from ..licensing import LicenseError
+    from ..engine import DEFAULT_PROFILE, PROFILES
+    from . import dashboard
+
+    tokens = split_args(args)
+    positional = _positional(tokens)
+    target = positional[0] if positional else ""
+    profile = _opt(tokens, "--profile", "-p") or session.config.scan.default_profile
+    project = _opt(tokens, "--project") or session.project
+
+    if profile not in PROFILES:
+        session.error(f"unknown profile '{profile}'", "available: " + ", ".join(sorted(PROFILES)))
+        return 2
+    if not target:
+        session.error("usage: /scan <apk> [--profile " + DEFAULT_PROFILE + "]")
+        return 2
+    if not Path(target).is_file():
+        session.error(f"target not found: {target}")
+        return 2
+    try:
+        gating.require(session.config, session.home, "scan")
+    except LicenseError as exc:
+        session.error(f"license required for 'scan': {exc}",
+                      "run /license to activate a key")
+        return 1
+
+    session.note(f"scanning {target} (profile={profile}, project={project})")
+    result = session.vr.scan(target, profile=profile, project=project)
+    dashboard.render_run(session.console, result)
+    session.render_findings(result.findings)
+    return 0
+
+
+def cmd_projects(session, args: str) -> int:
+    projects = session.vr.projects.list()
+    if not projects:
+        session.note("(no projects)")
+        return 0
+    session.console.table(["PROJECT", "RUNS", "ROOT"],
+                          [[p["name"], str(p["runs"]), p["root"]] for p in projects])
+    return 0
+
+
+def cmd_runs(session, args: str) -> int:
+    tokens = split_args(args)
+    project = _opt(tokens, "--project") or (_positional(tokens) or [session.project])[0]
+    ws = session.vr.projects.ensure(project)
+    db = session.vr.projects._db_for(ws.name)
+    runs = db.list_runs(ws.name)
+    if not runs:
+        session.note(f"(no runs for '{project}')")
+        return 0
+    session.console.table(["RUN", "PROFILE", "STATUS", "TARGET"],
+                          [[r["id"], r["profile"] or "", r["status"], r["target"] or ""] for r in runs])
+    return 0
+
+
+def cmd_findings(session, args: str) -> int:
+    tokens = split_args(args)
+    project = _opt(tokens, "--project") or session.project
+    run_id = _opt(tokens, "--run")
+    severity = _opt(tokens, "--severity", "-s")
+    if severity and severity not in SEVERITIES:
+        session.error(f"unknown severity '{severity}'", "one of: " + ", ".join(SEVERITIES))
+        return 2
+    ws = session.vr.projects.ensure(project)
+    db = session.vr.projects._db_for(ws.name)
+    rows = db.get_findings(run_id=run_id, project=None, severity=severity)
+    session.render_findings(rows)
+    session.note(f"{len(rows)} finding(s)")
+    return 0
+
+
+def cmd_tools(session, args: str) -> int:
+    tokens = split_args(args)
+    statuses = session.vr.tools.all_status()
+    session.cache_env(statuses)
+    rows = [[s.spec.name, session.status_text(s.status), (s.version or "")[:40],
+             s.spec.install_hint[:40]] for s in statuses]
+    session.console.table(["TOOL", "STATUS", "VERSION", "INSTALL HINT"], rows)
+    missing = [s for s in statuses if not s.available]
+    session.note(f"{len(statuses) - len(missing)} available, {len(missing)} missing")
+    if "--updates" in tokens or "--refresh" in tokens:
+        return cmd_updates(session, args)
+    return 0
+
+
+def cmd_rules(session, args: str) -> int:
+    tokens = split_args(args)
+    limit = _opt(tokens, "--limit")
+    rules = sorted(session.vr.rules.rules.values(), key=lambda r: r.id)
+    if limit and limit.isdigit():
+        rules = rules[: int(limit)]
+    session.console.table(["RULE", "SEV", "TARGET", "TITLE"],
+                          [[r.id, session.severity_text(r.severity), r.target, r.title[:50]] for r in rules])
+    session.note(f"{len(session.vr.rules)} rules loaded")
+    return 0
+
+
+def cmd_doctor(session, args: str) -> int:
+    import sys
+    from ..tools import REGISTRY
+
+    session.console.section("Environment")
+    session.console.kv([
+        ("python", sys.version.split()[0]),
+        ("platform", sys.platform),
+        ("home", session.home),
+        ("project", session.project),
+    ])
+    session.console.section("External tools")
+    statuses = session.vr.tools.all_status()
+    session.cache_env(statuses)
+    for s in statuses:
+        if s.available:
+            session.out(f"  {session.status_text('ok')}  {s.spec.name}  {(s.version or '')[:40]}")
+        else:
+            session.out(f"  {session.status_text('missing')}  {s.spec.name}  {s.spec.install_hint}")
+    session.console.section("Rules")
+    session.note(f"{len(session.vr.rules)} rules loaded from {len(REGISTRY)} tool specs")
+    return 0
+
+
+def cmd_updates(session, args: str) -> int:
+    from ..updates import UpdateChecker
+
+    tokens = split_args(args)
+    refresh = "--refresh" in tokens
+    offline = session.offline
+    session.console.section("Tool updates (stable releases)")
+    session.note("Checking official sources..." if not offline else "Reading cached release information...",
+                 muted=True)
+    results = UpdateChecker(session.vr.tools, session.vr.projects.home).check_all(
+        refresh=refresh, offline=offline)
+    session.console.table(["TOOL", "INSTALLED", "LATEST", "STATUS", "SOURCE"],
+                          [[r.name, r.installed or "?", r.latest or "?", r.status,
+                            "stale cache" if r.stale else "cache" if r.cached else "upstream"]
+                           for r in results])
+    for result in results:
+        if result.error:
+            session.note(f"  {result.name}: {result.error}", muted=True)
+    session.note("Release checks do not modify installed tools.", muted=True)
+    return 1 if any(r.status == "check_failed" for r in results) else 0
+
+
+def cmd_license(session, args: str) -> int:
+    from ..licensing import LicenseError
+
+    key = _opt(split_args(args), "--key")
+    if key:
+        try:
+            lic = session.client.activate(key).license or {}
+        except LicenseError as exc:
+            session.error(f"activation failed: {exc}")
+            return 1
+        session.success("device activated")
+        session.console.kv([
+            ("license", str(lic.get("id", "?"))),
+            ("role", str(lic.get("role", "?"))),
+            ("status", str(lic.get("status", "active"))),
+            ("permissions", ", ".join(lic.get("permissions") or [])),
+        ])
+        return 0
+
+    if not session.client.has_session():
+        session.note("no active session")
+        session.note("activate with: /license --key VR-XXXX", muted=True)
+        return 0
+    try:
+        data = session.client.me()
+    except LicenseError as exc:
+        session.error(str(exc))
+        return 1
+    lic = data.get("license", data)
+    last_check = ""
+    session_file = Path(session.home) / "session.json"
+    try:
+        last_check = f"{session_file.stat().st_mtime:.0f}"
+    except OSError:
+        pass
+    session.console.kv([
+        ("license", str(lic.get("id", "?"))),
+        ("role", str(lic.get("role", "?"))),
+        ("status", session.status_text(str(lic.get("status", "?")))),
+        ("device", str(lic.get("device_id", lic.get("deviceId", "?")))),
+        ("permissions", ", ".join(lic.get("permissions") or [])),
+        ("last check", session.human_time(last_check)),
+    ])
+    return 0
+
+
+def cmd_help(session, args: str) -> int:
+    from .components import palette
+
+    detail = args.strip().lstrip("/")
+    if detail:
+        command = COMMANDS.get("/" + detail)
+        if command is None:
+            session.error(f"unknown command '/{detail}'")
+            return 2
+        session.out(f"{session.theme.style(command.name, 'brand', 'bold')}  {command.summary}")
+        if command.usage:
+            session.note(command.usage, muted=True)
+        return 0
+    session.out(session.theme.style("Available commands", "brand", "bold"))
+    for name, summary in palette.COMMANDS:
+        session.out(f"  {session.theme.style(name.ljust(11), 'info')} {session.theme.style(summary, 'text')}")
+    session.note("Type a command or plain English (e.g. 'scan app.apk', 'quit').", muted=True)
+    return 0
+
+
+def cmd_clear(session, args: str) -> int:
+    return _CLEAR
+
+
+def cmd_exit(session, args: str) -> int:
+    return _EXIT
+
+
+# ----------------------------------------------------------------- registry
+_CLEAR = 1000
+_EXIT = 1001
+
+COMMANDS: dict[str, Command] = {
+    "/scan": Command("/scan", "Scan an APK or package", "/scan <apk> [--profile apk-static] [--project NAME]", cmd_scan),
+    "/projects": Command("/projects", "List projects", "/projects", cmd_projects),
+    "/runs": Command("/runs", "List runs for a project", "/runs [PROJECT]", cmd_runs),
+    "/findings": Command("/findings", "Show findings", "/findings [--run ID] [--severity SEV]", cmd_findings),
+    "/tools": Command("/tools", "External tools status", "/tools [--updates]", cmd_tools),
+    "/rules": Command("/rules", "List detection rules", "/rules [--limit N]", cmd_rules),
+    "/doctor": Command("/doctor", "Environment diagnostics", "/doctor", cmd_doctor),
+    "/updates": Command("/updates", "Check tool updates", "/updates [--refresh]", cmd_updates),
+    "/license": Command("/license", "Licence and device status", "/license [--key VR-XXXX]", cmd_license),
+    "/help": Command("/help", "Show available commands", "/help [command]", cmd_help),
+    "/clear": Command("/clear", "Clear the screen", "/clear", cmd_clear),
+    "/exit": Command("/exit", "Quit VulnReaper", "/exit", cmd_exit),
+}
+
+
+def names() -> list[str]:
+    return list(COMMANDS)
+
+
+def get(name: str) -> Command | None:
+    return COMMANDS.get(name.lower())

package/vendor/vulnreaper/cli/components/__init__.py

@@ -0,0 +1,11 @@
+"""Reusable, renderer-only UI components.
+
+Each component is a pure function (or small class) that takes a
+:class:`~vulnreaper.cli.theme.Theme` and returns styled strings.  Components
+never touch the engine or the licence system - they only format data.
+"""
+from __future__ import annotations
+
+from . import banner, error, finding, palette, spinner, status
+
+__all__ = ["banner", "error", "finding", "palette", "spinner", "status"]

package/vendor/vulnreaper/cli/components/banner.py

@@ -0,0 +1,81 @@
+"""Responsive ASCII banner for VulnReaper.
+
+Three tiers, chosen from the terminal width:
+
+* ``full``    - five-row block logotype (>= 100 columns)
+* ``compact`` - three-row box logotype (80-99 columns)
+* ``minimal`` - single plain word (narrow / ``TERM=dumb`` / no Unicode)
+
+The block logotype is our own, built from a small legible glyph set - it is
+NOT a copy of any other product's banner.  Colour is applied as a vertical
+violet -> cyan gradient by the theme.
+"""
+from __future__ import annotations
+
+from .. import terminal
+from ..theme import Theme, visible_len
+
+# Own block font, 5 rows tall, 7 columns wide per glyph (thickness 2 strokes).
+_FULL_FONT: dict[str, list[str]] = {
+    "V": ["██   ██", "██   ██", "██   ██", " ██ ██ ", "  ███  "],
+    "U": ["██   ██", "██   ██", "██   ██", "██   ██", " █████ "],
+    "L": ["██     ", "██     ", "██     ", "██     ", "███████"],
+    "N": ["██   ██", "███  ██", "██ █ ██", "██  ███", "██   ██"],
+    "R": ["██████ ", "██   ██", "██████ ", "██  ██ ", "██   ██"],
+    "E": ["███████", "██     ", "█████  ", "██     ", "███████"],
+    "A": [" █████ ", "██   ██", "███████", "██   ██", "██   ██"],
+    "P": ["██████ ", "██   ██", "██████ ", "██     ", "██     "],
+}
+
+# Own compact box-drawing logotype, 3 rows tall.
+_COMPACT = [
+    "\u2566  \u2566\u2566 \u2566\u2566  \u2554\u2557\u2554\u2566\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2554\u2550\u2557\u2566\u2554\u2550\u2557\u2566\u2550\u2557",
+    "\u255a\u2557\u2554\u255d\u2551 \u2551\u2551  \u2551\u2551\u2551\u2560\u2566\u255d\u2551\u2563 \u2560\u2550\u2563\u2560\u2550\u2563\u2551\u2551\u2563 \u2560\u2566\u255d",
+    " \u255a\u255d \u255a\u2550\u255d\u255a\u2550\u255d\u255d\u255a\u255d\u2569\u255a\u2550\u255a\u2550\u255d\u2569 \u2569\u2569 \u2569\u2569\u255a\u2550\u255d\u2569\u255a\u2550",
+]
+
+WORD = "VULNREAPER"
+TAGLINE = "AI-assisted Security Research Platform"
+
+
+def logotype_lines(tier: str) -> list[str]:
+    """Return the raw (unstyled) banner lines for a tier."""
+    if tier == "full":
+        rows = ["", "", "", "", ""]
+        for index, letter in enumerate(WORD):
+            glyph = _FULL_FONT[letter]
+            for r in range(5):
+                rows[r] += glyph[r]
+                if index != len(WORD) - 1:
+                    rows[r] += " "
+        return rows
+    if tier == "compact":
+        return list(_COMPACT)
+    return [WORD]
+
+
+def render(theme: Theme, cols: int | None = None) -> list[str]:
+    """Return styled banner lines that never exceed the terminal width."""
+    cols = terminal.columns() if cols is None else cols
+    tier = terminal.banner_tier(cols)
+    lines = logotype_lines(tier)
+    if terminal.ascii_mode() and tier != "minimal":
+        # The block glyphs need Unicode; fall back to the plain word.
+        tier = "minimal"
+        lines = [WORD]
+    styled = theme.gradient(lines, "brand", "info")
+    width = max(visible_len(line) for line in lines)
+    if width >= cols:
+        # Extremely narrow terminal: guarantee no overflow.
+        return [theme.style(WORD, "brand")]
+    return styled
+
+
+def tagline(theme: Theme) -> list[str]:
+    """Return the version/wordmark tagline lines."""
+    from ... import __version__
+
+    return [
+        theme.style(f"{WORD} {__version__}", "brand"),
+        theme.style(TAGLINE, "muted"),
+    ]

package/vendor/vulnreaper/cli/components/error.py

@@ -0,0 +1,29 @@
+"""Error rendering.
+
+One place decides how an error looks: a coloured glyph, the message, and an
+optional hint line for the usual remediation ("run vulnreaper login ...").
+"""
+from __future__ import annotations
+
+from .. import terminal
+from ..theme import Theme
+
+
+def render_error(theme: Theme, message: str, hint: str = "") -> list[str]:
+    glyph = theme.style(terminal.symbols()["cross"], "error")
+    lines = [f"{glyph} {theme.style(message, 'error')}"]
+    if hint:
+        lines.append(f"  {theme.style(hint, 'muted')}")
+    return lines
+
+
+def render_warning(theme: Theme, message: str, hint: str = "") -> list[str]:
+    glyph = theme.style(terminal.symbols()["diamond_o"], "warning")
+    lines = [f"{glyph} {theme.style(message, 'warning')}"]
+    if hint:
+        lines.append(f"  {theme.style(hint, 'muted')}")
+    return lines
+
+
+def render_success(theme: Theme, message: str) -> str:
+    return f"{theme.style(terminal.symbols()['check'], 'success')} {theme.style(message, 'text')}"