web-scanner 2.0.0__py3-none-any.whl

webscanner/ui/tables.py

@@ -0,0 +1,256 @@
+"""Rich renderables for the main data table and the fixed status panel."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Group, RenderableType
+from rich import box
+from rich.table import Table
+from rich.text import Text
+
+from ..colors import RED
+from ..core.context import ScanContext
+from ..core.models import Grid, Sections
+
+# Neutral, non-cyan key styling + a muted header + a very dim divider rule.
+KEY_STYLE = "bold"
+HEADER_STYLE = "bold grey62"
+DIVIDER_STYLE = "grey23"
+#: section-title chip — matches the selected-tab look (bg + 1-char side padding)
+SECTION_STYLE = "bold white on #393939"
+
+# Per-tab column headers (col1, col2). Meaningful names beat a generic pair since
+# each tab's data is different. (Tabs with multi-table results, e.g. Security,
+# carry headers per Section instead.)
+TAB_HEADERS: dict[str, tuple[str, str]] = {
+    "dns": ("Record", "Value"),
+    "whois": ("Field", "Value"),
+    "subdomains": ("#", "Subdomain"),
+    "ssl": ("Field", "Value"),
+    "headers": ("Header", "Value"),
+    "content": ("Field", "Value"),
+}
+
+
+#: cap on the (content-fit) first-column width
+MAX_KEY_WIDTH = 34
+
+
+def render_result(name: str, data: Any) -> RenderableType:
+    """Render a module's result: multi-column Grid, stacked sub-tables (Sections),
+    or one key/value table."""
+    if isinstance(data, Grid):
+        return render_grid(data)
+    if isinstance(data, Sections):
+        return render_sections(data)
+    return render_table(data, TAB_HEADERS.get(name))
+
+
+def render_grid(grid: Grid) -> Table:
+    """Render a multi-column table (e.g. Tech: Name/Category/Confidence/…).
+
+    First column is the primary name (bold); the rest are dim, matching the
+    key/value tables. Long list columns fold rather than truncate.
+    """
+    table = Table(
+        show_header=True,
+        header_style=HEADER_STYLE,
+        border_style=DIVIDER_STYLE,
+        box=box.SIMPLE,
+        expand=True,
+        pad_edge=False,
+        show_lines=False,
+        padding=(0, 1),
+    )
+    for i, col in enumerate(grid.columns):
+        if i == 0:
+            table.add_column(col, style=KEY_STYLE, no_wrap=True, overflow="ellipsis")
+        else:
+            table.add_column(col, style="dim", no_wrap=False, overflow="fold")
+    rows = [[str(cell) for cell in row] for row in grid]
+    for i, row in enumerate(rows):
+        table.add_row(*row)
+        if i != len(rows) - 1:
+            table.add_row(*[""] * len(grid.columns))  # blank spacer line
+    return table
+
+
+def render_sections(sections: Sections) -> Group:
+    """Render several titled sub-tables stacked; content-fit sections share one
+    first-column width, ratio sections use their fixed proportions."""
+    widths = [_col1_width(s.data, s.headers, upper=False) for s in sections if not s.ratio]
+    key_width = max([w for w in widths if w], default=None)
+    parts: list[RenderableType] = [Text("")]  # space above the first section title
+    for i, sec in enumerate(sections):
+        if i:
+            parts.append(Text(""))
+        # chip: 1-char padding inside the bg; the leading space also aligns the
+        # title text with the table's cell padding
+        parts.append(Text(f" {sec.title.upper()} ", style=SECTION_STYLE))
+        parts.append(
+            render_table(sec.data, sec.headers, upper=False, spaced=sec.spaced, key_width=key_width, ratio=sec.ratio)
+        )
+    return Group(*parts)
+
+
+def _stringify(value: Any) -> str:
+    if isinstance(value, (list, tuple, set)):
+        return "\n".join(str(v) for v in value) if value else "-"
+    if isinstance(value, bool):
+        return "yes" if value else "no"
+    if value is None:
+        return "-"
+    return str(value)
+
+
+def _label(key: Any, upper: bool) -> str:
+    s = str(key).replace("_", " ").replace("-", " ")
+    return s.upper() if upper else s
+
+
+def _is_pairs(data: Any) -> bool:
+    """True for a list of (col1, col2) tuples (e.g. the Links tables)."""
+    return (
+        isinstance(data, (list, tuple))
+        and bool(data)
+        and all(isinstance(x, (list, tuple)) and len(x) == 2 for x in data)
+    )
+
+
+def _value_cell(value: str) -> Text:
+    """Value cell: keep intentional colour markup (Security), otherwise dim."""
+    if "[/]" in value:
+        return Text.from_markup(value)
+    return Text(value, style="dim")
+
+
+def _col1_width(data: Any, headers: tuple[str, str] | None, upper: bool) -> int | None:
+    """Content-fit width for the first column (incl. its header), or None for a
+    fixed index column."""
+    c1 = (headers or ("Field", "Value"))[0]
+    if isinstance(data, dict):
+        labels = [len(_label(k, upper)) for k in data]
+    elif _is_pairs(data):
+        labels = [len(str(a)) for a, _ in data]
+    else:
+        return None  # list-of-scalars uses the fixed index width
+    return min(MAX_KEY_WIDTH, max(labels + [len(c1)], default=len(c1)))
+
+
+def render_table(
+    data: Any,
+    headers: tuple[str, str] | None = None,
+    upper: bool = True,
+    spaced: bool = True,
+    key_width: int | None = None,
+    ratio: tuple[int, int] | None = None,
+) -> Table:
+    """Generic key/value (dict), pair-list, or indexed (list) table.
+
+    ``headers`` labels the two columns. ``upper`` upper-cases dict keys. ``spaced``
+    inserts a blank line between rows. ``key_width`` fixes the first-column width
+    (content-fit by default). ``ratio`` (col1, col2) forces proportional columns
+    instead of content-fit (e.g. (3, 2) for 60/40).
+    """
+    table = Table(
+        show_header=headers is not None,
+        header_style=HEADER_STYLE,
+        border_style=DIVIDER_STYLE,  # very dim header rule
+        box=box.SIMPLE,
+        expand=True,
+        pad_edge=False,
+        show_lines=False,
+        padding=(0, 1),  # tight; row spacing added via spacer rows below
+    )
+    if key_width is None:
+        key_width = _col1_width(data, headers, upper)
+
+    if isinstance(data, dict) or _is_pairs(data):
+        if isinstance(data, dict):
+            c1, c2 = headers or ("Field", "Value")
+            rows = [(_label(k, upper), _value_cell(_stringify(v))) for k, v in data.items()]
+        else:
+            c1, c2 = headers or ("Name", "Value")
+            rows = [(str(a), _value_cell(str(b))) for a, b in data]
+        if ratio:
+            table.add_column(c1, style=KEY_STYLE, ratio=ratio[0], no_wrap=False, overflow="fold")
+            table.add_column(c2, ratio=ratio[1], no_wrap=False, overflow="fold")
+        else:
+            table.add_column(c1, style=KEY_STYLE, width=key_width, no_wrap=True, overflow="ellipsis")
+            table.add_column(c2, no_wrap=False, overflow="fold")
+        _add_spaced(table, rows, spaced)
+    elif isinstance(data, (list, tuple)):
+        c1, c2 = headers or ("#", "Value")
+        table.add_column(c1, style="dim", width=5)  # left-aligned index
+        table.add_column(c2, no_wrap=False, overflow="fold")
+        rows = [(str(i), _value_cell(str(row))) for i, row in enumerate(data, 1)]
+        _add_spaced(table, rows, spaced)
+    else:
+        table.add_column(headers[1] if headers else "Value")
+        table.add_row(_value_cell(str(data)))
+    return table
+
+
+def _add_spaced(table: Table, rows: list[tuple[str, Any]], spaced: bool = True) -> None:
+    """Add rows, optionally with a blank spacer line between them."""
+    for i, (a, b) in enumerate(rows):
+        table.add_row(a, b)
+        if spaced and i != len(rows) - 1:
+            table.add_row("", "")
+
+
+def _flag(country_code: str | None) -> str:
+    if not country_code or len(country_code) != 2:
+        return ""
+    return "".join(chr(0x1F1E6 + ord(c) - ord("A")) for c in country_code.upper())
+
+
+def render_status(ctx: ScanContext, tech: list[str] | None = None) -> Table:
+    """Fixed status panel: online state, IP, location, ISP/AS, key tech."""
+    geo = ctx.geo or {}
+    table = Table(
+        show_header=False,
+        box=None,
+        expand=True,
+        pad_edge=False,
+        padding=(0, 1, 1, 0),  # blank line under each row, matches main table
+    )
+    table.add_column("k", style=KEY_STYLE, width=10)
+    table.add_column("v", overflow="fold")
+
+    def dim(value: Any) -> Text:
+        return Text(str(value), style="dim")
+
+    if ctx.online:
+        state = Text.from_markup(
+            f"[green]● online[/]  [dim]{ctx.status_code} · {ctx.response_time_ms:.0f}ms[/]"
+        )
+    elif ctx.fetch_error is not None:
+        state = Text.from_markup(f"[{RED}]● offline[/]")
+    else:
+        state = Text.from_markup("[dim]…[/]")
+    table.add_row("Status", state)
+    table.add_row("IP", dim(ctx.ip or "-"))
+
+    # Location: flag emoji stays in colour (not dimmed), the text is dim.
+    if geo:
+        loc = Text()
+        flag = _flag(geo.get("countryCode"))
+        if flag:
+            loc.append(flag + " ")
+        loc.append(f"{geo.get('city', '-')}, {geo.get('country', '-')}", style="dim")
+    else:
+        loc = dim("-")
+    table.add_row("Location", loc)
+
+    # ip-api's `org` is often the actual host (e.g. "Pantheon") vs the network
+    # ISP/AS (e.g. "Fastly"); show it when present and distinct.
+    org = geo.get("org")
+    if org and org != geo.get("isp"):
+        table.add_row("Host", dim(org))
+    table.add_row("ISP", dim(geo.get("isp") or "-"))
+    table.add_row("AS", dim(geo.get("as") or "-"))
+    if tech:
+        table.add_row("Tech", dim(", ".join(tech[:8])))
+    return table

webscanner/ui/widgets.py

@@ -0,0 +1,101 @@
+"""Custom Textual widgets: tab bar, world-map panel, status panel."""
+
+from __future__ import annotations
+
+from textual.containers import Horizontal
+from textual.message import Message
+from textual.widgets import Static
+
+from ..core.context import ScanContext
+from ..core.models import ModuleStatus
+from .tables import render_status
+from .worldmap import country_name, render as render_map
+
+_STATUS_CLASSES = ("-pending", "-running", "-done", "-empty", "-failed")
+
+
+class Tab(Static):
+    """A single tab in the tab bar; colour reflects its module's status."""
+
+    class Clicked(Message):
+        def __init__(self, tab_name: str) -> None:
+            self.tab_name = tab_name
+            super().__init__()
+
+    def __init__(self, name: str, label: str) -> None:
+        super().__init__(label, id=f"tab-{name}")
+        self.tab_name = name
+        self.add_class("-pending")
+
+    def set_status(self, status: ModuleStatus) -> None:
+        self.remove_class(*_STATUS_CLASSES)
+        self.add_class(f"-{status.value}")
+
+    def set_selected(self, selected: bool) -> None:
+        self.set_class(selected, "-selected")
+
+    def on_click(self) -> None:
+        self.post_message(self.Clicked(self.tab_name))
+
+
+class TabBar(Horizontal):
+    def __init__(self, modules, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._modules = list(modules)
+
+    def compose(self):
+        for module in self._modules:
+            yield Tab(module.name, module.label)
+
+    def set_status(self, name: str, status: ModuleStatus) -> None:
+        self.query_one(f"#tab-{name}", Tab).set_status(status)
+
+    def set_selected(self, name: str) -> None:
+        for tab in self.query(Tab):
+            tab.set_selected(tab.tab_name == name)
+
+
+class MapPanel(Static):
+    """Fixed country-level location map; re-renders on resize to fill the panel."""
+
+    _geo: dict | None = None
+    _zoom: float = 1.0
+
+    def set_geo(self, geo: dict | None) -> None:
+        self._geo = geo
+        self._draw()
+
+    def zoom_by(self, direction: int) -> None:
+        factor = 1.3 if direction > 0 else 1 / 1.3
+        self._zoom = max(0.25, min(6.0, self._zoom * factor))
+        self._draw()
+
+    def show_loading(self) -> None:
+        self.update("[dim]locating…[/]")
+
+    def on_resize(self) -> None:
+        if self._geo is not None:
+            self._draw()
+
+    def _draw(self) -> None:
+        geo = self._geo or {}
+        lat, lon = geo.get("lat"), geo.get("lon")
+        if lat is None:
+            self.update("[dim]no location[/]")
+            return
+        width = max(20, self.content_size.width)
+        height = max(6, self.content_size.height)
+        country = geo.get("country") or country_name(lat, lon) or "?"
+        self.border_title = f"Location — {country}"
+        self.border_subtitle = "+/- zoom"
+        self.update(render_map(lat, lon, cols=width, rows=height, zoom=self._zoom))
+
+
+class StatusPanel(Static):
+    """Fixed status summary panel."""
+
+    def show_loading(self, ctx: ScanContext) -> None:
+        self.update(f"[dim]scanning {ctx.domain}…[/]")
+
+    def set_ctx(self, ctx: ScanContext, tech: list[str] | None = None) -> None:
+        self.update(render_status(ctx, tech))

webscanner/ui/worldmap.py

@@ -0,0 +1,197 @@
+"""Country-level location map, rendered from embedded country borders.
+
+Re-engineered from the old coarse box model: it loads low-resolution Natural
+Earth country polygons (``data/countries.json``, built once from the 110m
+dataset), auto-frames the view to the server's country plus surrounding
+countries, and rasterises the real border lines into a braille grid with the
+location marked. Projection is equirectangular with a cos(latitude) correction
+so shapes aren't stretched. No zoom — the frame is chosen automatically.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from functools import lru_cache
+from pathlib import Path
+
+from rich.text import Text
+
+_DATA = Path(__file__).parent / "data" / "countries.json"
+_CHAR_ASPECT = 2.0  # terminal cell height:width
+
+# braille dot bit for a (row, col) within a 2-wide x 4-tall cell
+_BITS = {
+    (0, 0): 0x01, (1, 0): 0x02, (2, 0): 0x04, (3, 0): 0x40,
+    (0, 1): 0x08, (1, 1): 0x10, (2, 1): 0x20, (3, 1): 0x80,
+}
+
+Ring = list[tuple[float, float]]
+BBox = tuple[float, float, float, float]  # minlon, minlat, maxlon, maxlat
+
+
+@lru_cache(maxsize=1)
+def _countries() -> list[tuple[str, list[tuple[Ring, BBox]]]]:
+    """Load countries as (name, [(ring, bbox), ...]); cached for the process."""
+    raw = json.loads(_DATA.read_text())
+    out = []
+    for country in raw:
+        rings = []
+        for ring in country["r"]:
+            pts = [(p[0], p[1]) for p in ring]
+            if len(pts) < 3:
+                continue
+            lons = [p[0] for p in pts]
+            lats = [p[1] for p in pts]
+            rings.append((pts, (min(lons), min(lats), max(lons), max(lats))))
+        out.append((country["n"], rings))
+    return out
+
+
+def _point_in_ring(lon: float, lat: float, ring: Ring) -> bool:
+    inside = False
+    n = len(ring)
+    j = n - 1
+    for i in range(n):
+        xi, yi = ring[i]
+        xj, yj = ring[j]
+        if (yi > lat) != (yj > lat):
+            x_cross = (xj - xi) * (lat - yi) / (yj - yi) + xi
+            if lon < x_cross:
+                inside = not inside
+        j = i
+    return inside
+
+
+def _containing_ring(lat: float, lon: float) -> tuple[str, BBox] | None:
+    """Return (country_name, bbox) of the specific landmass ring under (lat, lon)."""
+    for name, rings in _countries():
+        for ring, (mnx, mny, mxx, mxy) in rings:
+            if mnx <= lon <= mxx and mny <= lat <= mxy and _point_in_ring(lon, lat, ring):
+                return name, (mnx, mny, mxx, mxy)
+    return None
+
+
+def render(
+    lat: float | None = None,
+    lon: float | None = None,
+    cols: int = 56,
+    rows: int = 14,
+    zoom: float = 1.0,
+    marker: str = "●",
+    marker_style: str = "bold green",
+    border_style: str = "grey58",
+    home_style: str = "grey85",
+) -> Text:
+    """Render an outline map framed on the server's country + neighbours.
+
+    ``zoom`` > 1 tightens the frame (closer), < 1 widens it (more surroundings).
+    """
+    cols, rows = max(8, cols), max(4, rows)
+    if lat is None or lon is None:
+        return Text("no location", style="dim")
+
+    hit = _containing_ring(lat, lon)
+    home_name = hit[0] if hit else None
+    if hit:
+        mnx, mny, mxx, mxy = hit[1]
+    else:  # ocean / unmatched — frame a default box around the marker
+        mnx, mny, mxx, mxy = lon - 6, lat - 6, lon + 6, lat + 6
+
+    cx, cy = (mnx + mxx) / 2, (mny + mxy) / 2
+    # frame span: country size + margin, with a floor so tiny countries aren't over-zoomed
+    lon_span = max(mxx - mnx, 6.0) * 1.6
+    lat_span = max(mxy - mny, 4.0) * 1.6
+
+    # aspect fit (cos-corrected) — expand the deficient axis so nothing distorts
+    k = max(0.15, math.cos(math.radians(cy)))
+    target = cols / (2 * rows)  # desired projected width:height for square pixels
+    if (lon_span * k) / lat_span < target:
+        lon_span = target * lat_span / k
+    else:
+        lat_span = (lon_span * k) / target
+
+    lon_span /= zoom  # user zoom (both axes equally → aspect preserved)
+    lat_span /= zoom
+
+    # Keep the marker inside the frame (within the central 80%) at any zoom, by
+    # nudging the frame centre toward it — so zooming in never loses the point.
+    cx = min(max(cx, lon - lon_span * 0.4), lon + lon_span * 0.4)
+    cy = min(max(cy, lat - lat_span * 0.4), lat + lat_span * 0.4)
+
+    lon0, lat_top = cx - lon_span / 2, cy + lat_span / 2
+    pw, ph = cols * 2, rows * 4
+    view = (lon0, cy - lat_span / 2, lon0 + lon_span, lat_top)  # for bbox culling
+
+    def to_px(lon_: float, lat_: float) -> tuple[float, float]:
+        return (lon_ - lon0) / lon_span * pw, (lat_top - lat_) / lat_span * ph
+
+    grid = [bytearray(pw) for _ in range(ph)]  # 0 empty, 1 border, 2 home border
+
+    def plot(x: int, y: int, v: int) -> None:
+        if 0 <= x < pw and 0 <= y < ph and grid[y][x] < v:
+            grid[y][x] = v
+
+    def draw_line(x0: float, y0: float, x1: float, y1: float, v: int) -> None:
+        # integer Bresenham over the (possibly out-of-range) endpoints
+        xi0, yi0, xi1, yi1 = int(x0), int(y0), int(x1), int(y1)
+        dx, dy = abs(xi1 - xi0), -abs(yi1 - yi0)
+        sx = 1 if xi0 < xi1 else -1
+        sy = 1 if yi0 < yi1 else -1
+        err = dx + dy
+        while True:
+            plot(xi0, yi0, v)
+            if xi0 == xi1 and yi0 == yi1:
+                break
+            e2 = 2 * err
+            if e2 >= dy:
+                err += dy
+                xi0 += sx
+            if e2 <= dx:
+                err += dx
+                yi0 += sy
+
+    vmnx, vmny, vmxx, vmxy = view
+    for name, rings in _countries():
+        v = 2 if name == home_name else 1
+        for ring, (rmnx, rmny, rmxx, rmxy) in rings:
+            if rmxx < vmnx or rmnx > vmxx or rmxy < vmny or rmny > vmxy:
+                continue  # ring entirely outside view
+            prev = ring[-1]
+            for cur in ring:
+                x0, y0 = to_px(*prev)
+                x1, y1 = to_px(*cur)
+                draw_line(x0, y0, x1, y1, v)
+                prev = cur
+
+    mpx, mpy = to_px(lon, lat)
+    mcx, mcy = int(mpx) // 2, int(mpy) // 4
+
+    text = Text()
+    for cyc in range(rows):
+        for cxc in range(cols):
+            if cxc == mcx and cyc == mcy:
+                text.append(marker, style=marker_style)
+                continue
+            bits = home = 0
+            for (r, c), bit in _BITS.items():
+                cell = grid[cyc * 4 + r][cxc * 2 + c]
+                if cell:
+                    bits |= bit
+                    if cell == 2:
+                        home = 1
+            if bits:
+                text.append(chr(0x2800 + bits), style=home_style if home else border_style)
+            else:
+                text.append(" ")
+        if cyc != rows - 1:
+            text.append("\n")
+    return text
+
+
+def country_name(lat: float | None, lon: float | None) -> str | None:
+    """Name of the country at (lat, lon), for the panel title (or None)."""
+    if lat is None or lon is None:
+        return None
+    hit = _containing_ring(lat, lon)
+    return hit[0] if hit else None