web-scanner 2.2.0__tar.gz → 2.2.2__tar.gz

{web_scanner-2.2.0 → web_scanner-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web-scanner
-Version: 2.2.0
+Version: 2.2.2
 Summary: An async Textual TUI for website reconnaissance — DNS, WHOIS, TLS, security, tech-stack and SEO, with no paid APIs.
 Project-URL: Homepage, https://github.com/iamramizk/web-scanner
 Project-URL: Repository, https://github.com/iamramizk/web-scanner

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/__init__.py

@@ -1,3 +1,3 @@
 """web-scanner v2 — async website reconnaissance TUI package."""
 
-__version__ = "2.2.0"
+__version__ = "2.2.2"

web_scanner-2.2.2/webscanner/cli.py

@@ -0,0 +1,36 @@
+"""Console entry point for the ``webscan`` command.
+
+    webscan example.com
+    python -m webscanner example.com
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from webscanner.helpers import is_valid_url
+from webscanner.ui.app import WebScannerApp
+
+
+def main() -> None:
+    target = sys.argv[1].strip() if len(sys.argv) > 1 else None
+    if target and not is_valid_url(target):
+        print(f"[!] Not a valid target: {target}")
+        raise SystemExit(1)
+    WebScannerApp(target).run()
+    # Textual has already restored the terminal by the time run() returns.
+    # Quitting mid-scan cancels the scan worker's coroutine, but the blocking
+    # work it dispatched via asyncio.to_thread (requests/socket/pydig/Wappalyzer,
+    # each up to ~12–30s of timeout) keeps running in asyncio's default thread
+    # pool. Those are non-daemon threads, so concurrent.futures' atexit handler
+    # joins them on interpreter shutdown and the process hangs after the UI is
+    # gone. os._exit bypasses that join and terminates now — safe here: the
+    # terminal is restored and there is no post-scan state left to flush.
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(0)
+
+
+if __name__ == "__main__":
+    main()

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/colors.py

@@ -5,6 +5,9 @@ RED = "#FF6C64"
 #: matches the app's primary theme blue ($primary, textual-dark) — progress bar,
 #: selected-tab chip, keybar hints.
 BLUE = "#0178D4"
+#: update-available signal — the status-bar version dot when a newer PyPI release
+#: exists (green = up to date, blue = not yet checked / couldn't check).
+ORANGE = "#F5A623"
 #: muted value/secondary text — matches the unselected-tab colour
 #: ($text-muted = white @ 60% over the dark theme bg).
 MUTED = "#9D9D9D"

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/core/models.py

@@ -70,13 +70,17 @@ class TreeNode:
     site's URL-path hierarchy (``/blog`` → ``/blog/post-1`` …). A node is a branch
     (expandable folder) iff it has ``children``; otherwise it's a leaf (a page). The
     UI turns the root into a Textual ``Tree`` widget. ``total`` (set on the root only)
-    is the count of page URLs behind the tree, shown in the panel subtitle. ``url`` is
-    the full page URL a node stands for (set on leaves), so the UI can make it clickable.
+    is the count of URLs behind the tree, split into ``pages`` + ``assets`` (also
+    root-only), a purely parsed classification by file extension — see
+    ``sitemap._is_asset``; shown in the panel subtitle. ``url`` is the full page URL a
+    node stands for (set on leaves), so the UI can make it clickable.
     """
 
     label: str
     children: list["TreeNode"] = field(default_factory=list)
     total: int | None = None
+    pages: int | None = None
+    assets: int | None = None
     url: str | None = None
 
 

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/modules/sitemap.py

@@ -37,6 +37,32 @@ MAX_URLS = 10000
 #: how deep a chain of nested <sitemapindex> files we follow
 MAX_DEPTH = 6
 
+#: File extensions that mark a sitemap ``<loc>`` as a downloadable **asset**
+#: (image / media / document / archive / static file) rather than a page.
+#: Classification is *pure parsing* — read off the URL path, never fetched.
+#: Anything not listed here (no extension, ``.html``/``.php``, a dynamic route,
+#: a trailing slash) counts as a page, so the bias is toward "page" and odd
+#: dynamic URLs aren't mislabelled.
+ASSET_EXTENSIONS = frozenset({
+    # images
+    "jpg", "jpeg", "png", "gif", "webp", "svg", "bmp", "ico",
+    "tif", "tiff", "avif", "heic", "heif",
+    # audio / video
+    "mp3", "mp4", "wav", "ogg", "oga", "webm", "mov", "avi", "mkv",
+    "flv", "m4a", "m4v", "wmv", "aac", "flac",
+    # documents
+    "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "odt", "ods",
+    "odp", "rtf", "csv", "tsv", "epub",
+    # archives
+    "zip", "gz", "tgz", "tar", "rar", "7z", "bz2", "xz",
+    # web / static assets
+    "css", "js", "mjs", "map", "wasm", "rss", "atom",
+    # fonts
+    "woff", "woff2", "ttf", "otf", "eot",
+    # binaries / packages
+    "dmg", "exe", "apk", "pkg", "iso", "bin", "deb", "rpm", "msi",
+})
+
 
 class SitemapModule(ScanModule):
     name = "sitemap"
@@ -158,6 +184,17 @@ def _localname(tag: str) -> str:
     return tag.rsplit("}", 1)[-1].lower()
 
 
+def _is_asset(url: str) -> bool:
+    """True if `url`'s path names a downloadable asset (by file extension) rather
+    than a page. Pure parsing — no request is ever made. The extension is taken
+    from the last path segment only (query/fragment ignored); a missing or
+    unknown extension, or a trailing slash, counts as a page."""
+    last = urlparse(url).path.rsplit("/", 1)[-1]
+    if "." not in last:
+        return False
+    return last.rsplit(".", 1)[-1].lower() in ASSET_EXTENSIONS
+
+
 def _segments(url: str, include_host: bool) -> list[str]:
     """Path segments for `url` as tree labels: ``/blog``, ``/post`` … An empty path
     (the homepage) yields ``[]`` — it *is* the ``/`` root, not a child of it. When
@@ -196,6 +233,8 @@ def _url_tree(urls: list[str], truncated: bool) -> TreeNode:
     if truncated:
         root.children.append(TreeNode(label=f"… (truncated at {MAX_URLS} URLs)"))
     root.total = len(urls)
+    root.assets = sum(1 for u in urls if _is_asset(u))
+    root.pages = root.total - root.assets
     _sort_tree(root)
     return root
 

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/net/version_check.py

@@ -62,11 +62,17 @@ def _write_cache(latest: str) -> None:
     path.write_text(json.dumps({"latest": latest, "checked_at": time.time()}))
 
 
-def check_for_update(current: str) -> str | None:
-    """The latest PyPI version if newer than ``current``, else ``None``.
+def update_status(current: str) -> tuple[str, str | None]:
+    """The update state as ``(status, latest)``:
 
-    Silent on any failure — network, parse, or filesystem — since a broken update
-    check must never be visible as a scan problem.
+    - ``("outdated", latest)`` — a newer PyPI release exists;
+    - ``("latest", None)`` — confirmed up to date;
+    - ``("unknown", None)`` — couldn't check (network, parse, or filesystem failure).
+
+    The ``unknown`` case is kept distinct from ``latest`` on purpose: the status-bar
+    dot shows green only for a *confirmed* up-to-date check, and stays neutral (blue)
+    when the check couldn't complete — a broken update check must never look like a
+    scan problem, nor falsely claim "up to date".
     """
     try:
         latest = _cached_latest()
@@ -76,6 +82,18 @@ def check_for_update(current: str) -> str | None:
         if latest is None:
             latest = _fetch_latest()
             _write_cache(latest)
-        return latest if _parse(latest) > _parse(current) else None
     except Exception:  # noqa: BLE001
-        return None
+        return "unknown", None
+    if _parse(latest) > _parse(current):
+        return "outdated", latest
+    return "latest", None
+
+
+def check_for_update(current: str) -> str | None:
+    """The latest PyPI version if newer than ``current``, else ``None``.
+
+    Silent on any failure — network, parse, or filesystem — since a broken update
+    check must never be visible as a scan problem.
+    """
+    status, latest = update_status(current)
+    return latest if status == "outdated" else None

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/ui/activity.py

@@ -25,9 +25,12 @@ from __future__ import annotations
 import re
 from typing import Any, Callable
 
+from urllib.parse import urlparse
+
 from rich.markup import escape
 
-from ..colors import BLUE, GREEN, RED
+from ..colors import GREEN, RED
+from ..net.psl import registrable_domain
 from ..core.context import ScanContext
 from ..core.models import ModuleResult, ModuleStatus, ScanEvent
 from ..core.scanner import PREFETCH, SHARED_IP
@@ -129,6 +132,20 @@ def _dns(result: ModuleResult) -> str:
     return f"{line} · {', '.join(auth)}." if auth else f"{line}."
 
 
+def _registrar_root(url: str | None) -> str:
+    """Registrar's registrable domain from its WHOIS ``registrar_url``.
+
+    ``http://www.hostinger.com`` → ``hostinger.com``. Tolerates a scheme-less
+    value (``www.hostinger.com``) — ``urlparse`` puts that in ``path``, not
+    ``netloc``, so fall back to the whole string as the host. Returns "" when
+    nothing usable (no URL, or no registrable domain resolves)."""
+    if not url:
+        return ""
+    parsed = urlparse(url.strip())
+    host = parsed.netloc or parsed.path
+    return registrable_domain(host.split("/")[0].split("@")[-1])
+
+
 def _whois(result: ModuleResult) -> str:
     data = result.data or {}
     if not data:
@@ -136,7 +153,11 @@ def _whois(result: ModuleResult) -> str:
     if (note := _note(data)) is not None:
         return f"{_DONE}. {_sentence(note)}"
     bits = []
-    if registrar := data.get("registrar"):
+    # Prefer the registrar's root domain (registrable eTLD+1 of its URL) over its
+    # legal name — "hostinger.com" reads truer than "HOSTINGER operations, UAB".
+    # Fall back to the name when there's no URL (sparse ccTLD output).
+    registrar = _registrar_root(data.get("registrar_url")) or data.get("registrar")
+    if registrar:
         # Unlabelled: the Whois prefix and the "expires" half make it obvious enough,
         # and the 10 chars "Registrar " costs are better spent on the name itself.
         bits.append(_esc(registrar))
@@ -237,7 +258,12 @@ def _sitemap(result: ModuleResult) -> str:
         return f"{_DONE}. No sitemap found."
     total = root.total or 0
     suffix = " (truncated)" if total >= MAX_URLS else ""
-    return f"{_DONE}. {_plural(total, 'URL')} found{suffix}."
+    assets = root.assets or 0
+    pages = root.pages if root.pages is not None else total
+    tally = _plural(pages, "page")
+    if assets:
+        tally += f", {_plural(assets, 'asset')}"
+    return f"{_DONE}. {tally} found{suffix}."
 
 
 def _links(result: ModuleResult) -> str:
@@ -338,12 +364,6 @@ def waf(result: ModuleResult) -> str | None:
     return f"{line} · actively blocking." if blocked else f"{line}."
 
 
-def update_available(latest: str) -> str:
-    """A newer release exists on PyPI. Emitted once, after the scan's own closing
-    line, only when a newer version was actually found — see net/version_check.py."""
-    return f"Update: [{BLUE}]v{_esc(latest)} available[/] — run `pipx upgrade web-scanner`."
-
-
 def overall(completed: int, failed: int, total: int, seconds: float) -> str:
     """The closing line. ``seconds`` is wall-clock for the whole scan — modules run
     concurrently, so summing their durations would overstate it several-fold."""

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/ui/app.py

@@ -17,6 +17,7 @@ import re
 import time
 
 from bs4 import BeautifulSoup
+from rich.padding import Padding
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Grid, Horizontal, Vertical, VerticalScroll
@@ -24,19 +25,36 @@ from textual.message import Message
 from textual.widgets import Input, LoadingIndicator, Static
 
 from .. import __version__
+from ..colors import BLUE, GREEN, ORANGE
 from ..core import AsyncScanner, ModuleStatus, ScanContext, ScanEvent
 from ..core.scanner import PREFETCH, SHARED_IP
 from ..modules import all_modules
-from ..net.version_check import check_for_update
+from ..net.version_check import update_status
 from . import activity
 from .export import export_csvs
-from .tables import UNSET, render_result
+from .tables import UNSET, render_result, render_status
 from .widgets import ActivityLog, MapPanel, SitemapTree, StatusPanel, TabBar, Tab
 
 #: width (cells) of the footer progress bar and its dim (incomplete) colour
 _BAR_WIDTH = 22
 _BAR_DIM = "grey30"
 
+#: colour of the status-bar version dot per update state (see net/version_check.py):
+#: blue until the background check answers / if it couldn't, green = up to date,
+#: orange = a newer PyPI release is available.
+_DOT_COLOURS = {"unknown": BLUE, "latest": GREEN, "outdated": ORANGE}
+
+#: below this terminal width the layout collapses to a single column (the fixed map
+#: + Server panels become tabs, activity becomes a tab) — see _apply_narrow.
+_NARROW_MAX = 90
+
+#: pseudo-tabs shown only in the narrow layout, before the real module tabs: the
+#: Activity log and the Server panel, which are fixed side/bottom panels on wide
+#: terminals. (name, label) — names must not collide with any module name.
+_PSEUDO_TABS: tuple[tuple[str, str], ...] = (("activity", "Activity"), ("server", "Server"))
+_PSEUDO_NAMES = frozenset(name for name, _ in _PSEUDO_TABS)
+_PSEUDO_LABELS = {name: label for name, label in _PSEUDO_TABS}
+
 
 def _cms_from_tech(data: object) -> tuple[str, str | None] | None:
     """The CMS (name, version) from the Tech result, or ``None`` if none detected.
@@ -121,6 +139,20 @@ def _detect_cms(tech_data: object, html: str | None) -> tuple[str, str | None] |
     return tech
 
 
+def _sitemap_subtitle(root: object) -> str:
+    """The Sitemap tab's ``#main`` subtitle: ``"12 pages • 3 assets"`` (pages vs.
+    assets split purely by URL extension — see ``sitemap._is_asset``). Assets are
+    only shown when present; falls back to the raw total if the split is missing."""
+    pages = getattr(root, "pages", None)
+    assets = getattr(root, "assets", None) or 0
+    if pages is None:  # older/other tree without the split — show the plain count
+        return f"{getattr(root, 'total', 0) or 0} Total"
+    parts = [f"{pages} {'page' if pages == 1 else 'pages'}"]
+    if assets:
+        parts.append(f"{assets} {'asset' if assets == 1 else 'assets'}")
+    return " • ".join(parts)
+
+
 class ScanProgress(Message):
     """A ScanEvent surfaced onto the Textual message pump."""
 
@@ -134,10 +166,14 @@ class ScanFinished(Message):
 
 
 class VersionChecked(Message):
-    """Result of the background PyPI update check (see net/version_check.py)."""
+    """Result of the background PyPI update check (see net/version_check.py).
 
-    def __init__(self, latest: str | None) -> None:
-        self.latest = latest
+    ``status`` is one of ``"unknown"`` / ``"latest"`` / ``"outdated"`` — it drives
+    the colour of the status-bar version dot.
+    """
+
+    def __init__(self, status: str) -> None:
+        self.status = status
         super().__init__()
 
 
@@ -166,6 +202,10 @@ class WebScannerApp(App):
         Binding("minus,underscore", "zoom_out", "Zoom map out", show=False),
         Binding("pageup", "scroll_main_up", "Scroll up", show=False),
         Binding("pagedown", "scroll_main_down", "Scroll down", show=False),
+        # Number keys jump to the Nth visible tab: 1 = first tab (DNS when wide,
+        # Activity when narrow) … 9 = ninth, 0 = tenth. Not priority, so a digit typed
+        # into the focused domain input is entered as text rather than switching tabs.
+        *[Binding(str(d), f"select_tab({d})", show=False) for d in range(10)],
     ]
 
     def __init__(self, target: str | None = None) -> None:
@@ -184,6 +224,9 @@ class WebScannerApp(App):
         # value handed to StatusPanel so the export matches what's on screen.
         self._cms: object = UNSET
         self.selected = self.modules[0].name
+        # Narrow (phone-width) layout: right column + activity strip become tabs.
+        # Applied for real in on_mount/on_resize once the terminal size is known.
+        self._narrow = False
         self.completed = 0
         self.failed = 0
         self._scanning = False
@@ -193,18 +236,16 @@ class WebScannerApp(App):
         # last result rendered into the sitemap Tree, so switching tabs doesn't
         # rebuild (and re-collapse) it every visit.
         self._tree_result = None
-        # background PyPI update check (see _check_version) — announced once, after
-        # whichever finishes last: the scan or the check itself.
-        self._update_available: str | None = None
-        self._version_checked = False
-        self._update_announced = False
+        # background PyPI update check (see _check_version) — drives the colour of the
+        # status-bar version dot. "unknown" (blue) until the check answers.
+        self._version_status = "unknown"
 
     # ---- layout -----------------------------------------------------------
 
     def compose(self) -> ComposeResult:
         with Vertical(id="topbar"):
             yield Input(value=self._target or "", placeholder="domain… (press enter to scan)", id="domain")
-            yield TabBar(self.modules, id="tabs")
+            yield TabBar(self.modules, pseudo=_PSEUDO_TABS, id="tabs")
         with Grid(id="grid"):
             with Vertical(id="left"):
                 with VerticalScroll(id="main"):
@@ -225,8 +266,11 @@ class WebScannerApp(App):
         self.query_one("#status", VerticalScroll).border_title = "Server"
         self.query_one("#activity", ActivityLog).border_title = "Activity Log"
         self.query_one("#tabs", TabBar).set_selected(self.selected)
-        self._update_main_title()
-        self._set_keybar(editing=False)
+        # Establish the layout (wide vs narrow) before the first paint / scan.
+        self._apply_narrow(self.size.width < _NARROW_MAX)
+        # Show the version + (blue) update dot straight away; the dot recolours once
+        # the background check answers, and the progress bar reclaims the slot mid-scan.
+        self._refresh_version()
         # own group: the scan worker below is exclusive=True, which cancels every
         # other worker in its group — a shared/default group would kill this one.
         self.run_worker(
@@ -237,27 +281,52 @@ class WebScannerApp(App):
         else:
             self.action_toggle_edit()
 
+    def on_resize(self, event) -> None:
+        """Switch between the wide and narrow layouts as the terminal is resized."""
+        narrow = event.size.width < _NARROW_MAX
+        if narrow != self._narrow:
+            self._apply_narrow(narrow)
+
+    def _apply_narrow(self, narrow: bool) -> None:
+        """Toggle the single-column phone layout.
+
+        Adds/removes the ``-narrow`` class on the Screen (which drives the CSS: the
+        map + Server panels hide, the grid collapses to one column) and re-derives the
+        Python-side state that CSS can't: the visible tab set (Activity/Server become
+        real tabs), the selected tab (a pseudo tab can't stay selected once it vanishes
+        on the way back to wide), and which of #main / #activity is shown.
+        """
+        self._narrow = narrow
+        if self.screen is not None:
+            self.screen.set_class(narrow, "-narrow")
+        if narrow:
+            # Entering narrow: select the first tab (Activity), mirroring how DNS is
+            # the default first tab on wide terminals.
+            self.selected = _PSEUDO_TABS[0][0]
+        elif self.selected in _PSEUDO_NAMES:
+            # The pseudo tabs don't exist on wide terminals — fall back to the first
+            # real module tab so the selection stays valid.
+            self.selected = self.modules[0].name
+        self.query_one("#tabs", TabBar).set_selected(self.selected)
+        self._refresh_main()
+        editing = self.focused is not None and self.focused.id == "domain"
+        self._set_keybar(editing=editing)
+
     async def _check_version(self) -> None:
-        latest = await asyncio.to_thread(check_for_update, __version__)
-        self.post_message(VersionChecked(latest))
+        status, _latest = await asyncio.to_thread(update_status, __version__)
+        self.post_message(VersionChecked(status))
 
     def on_version_checked(self, message: VersionChecked) -> None:
-        self._update_available = message.latest
-        self._version_checked = True
-        self._maybe_announce_update()
-
-    def _maybe_announce_update(self) -> None:
-        if (
-            self._update_announced
-            or self._scanning
-            or not self._version_checked
-            or self._update_available is None
-        ):
+        self._version_status = message.status
+        self._refresh_version()
+
+    def _refresh_version(self) -> None:
+        """Draw the version + update dot at the right of the footer, unless a scan is
+        in progress (then the progress bar owns that slot — restored on finish)."""
+        if self._scanning:
             return
-        self._update_announced = True
-        self.query_one("#activity", ActivityLog).add(
-            activity.update_available(self._update_available)
-        )
+        dot = _DOT_COLOURS.get(self._version_status, BLUE)
+        self.query_one("#progress", Static).update(f"v{__version__} [{dot}]•[/]")
 
     # ---- scanning ---------------------------------------------------------
 
@@ -314,12 +383,14 @@ class WebScannerApp(App):
             if event.status is ModuleStatus.DONE and self.ctx is not None:
                 self.query_one("#map", MapPanel).set_geo(self.ctx.geo)
                 self.query_one("#status-content", StatusPanel).set_ctx(self.ctx)
+                self._refresh_server_tab()
             return
         if event.name == SHARED_IP:
             # Not a module — a late panel-only refresh once the shared-IP lookup lands.
             # Re-pass the tracked CMS so a completed Tech row isn't dropped back to UNSET.
             if self.ctx is not None:
                 self.query_one("#status-content", StatusPanel).set_ctx(self.ctx, cms=self._cms)
+                self._refresh_server_tab()
             return
 
         self.query_one("#tabs", TabBar).set_status(event.name, event.status)
@@ -351,6 +422,7 @@ class WebScannerApp(App):
             detected = _detect_cms(data, self.ctx.html)
             self._cms = detected
             self.query_one("#status-content", StatusPanel).set_ctx(self.ctx, cms=detected)
+            self._refresh_server_tab()
             self.query_one("#activity", ActivityLog).add(activity.cms(detected))
         self._update_progress()
 
@@ -362,8 +434,7 @@ class WebScannerApp(App):
                 self.completed, self.failed, total, time.monotonic() - self._scan_start
             )
         )
-        self.query_one("#progress", Static).update(f"v{__version__}")
-        self._maybe_announce_update()
+        self._refresh_version()
 
     # ---- progress line ----------------------------------------------------
 
@@ -386,17 +457,30 @@ class WebScannerApp(App):
     def _module_names(self) -> list[str]:
         return [m.name for m in self.modules]
 
+    def _nav_names(self) -> list[str]:
+        """Tab names in cycle order — the pseudo tabs (Activity/Server) lead the list
+        in the narrow layout, and are absent (fixed panels) when wide."""
+        names = self._module_names()
+        if self._narrow:
+            return [name for name, _ in _PSEUDO_TABS] + names
+        return names
+
     def _select(self, name: str) -> None:
         self.selected = name
         self.query_one("#tabs", TabBar).set_selected(name)
         self._refresh_main()
+        # Reset the shared main-panel scroll so a tab left scrolled-down doesn't carry
+        # its offset onto the next tab (they all share the one #main VerticalScroll).
+        self.query_one("#main", VerticalScroll).scroll_home(animate=False)
         # keybar depends on the selected tab (Sitemap shows tree-nav hints); keep
         # the editing state if the domain input still has focus.
         editing = self.focused is not None and self.focused.id == "domain"
         self._set_keybar(editing=editing)
 
     def _update_main_title(self) -> None:
-        label = next(m.label for m in self.modules if m.name == self.selected)
+        label = _PSEUDO_LABELS.get(self.selected) or next(
+            m.label for m in self.modules if m.name == self.selected
+        )
         main = self.query_one("#main")
         main.border_title = label
         main.border_subtitle = ""  # only the Sitemap tab sets one (URL total)
@@ -412,15 +496,54 @@ class WebScannerApp(App):
         self.query_one("#main-loading", LoadingIndicator).display = loading
         self.query_one("#main-content", Static).display = not loading
 
+    def _main_avail(self) -> int | None:
+        """Character width available to the main-panel table (inside border + padding),
+        or None before the panel is laid out — the table renderer then skips the ⅓ cap."""
+        width = self.query_one("#main", VerticalScroll).content_size.width
+        return width or None
+
     def _refresh_main(self) -> None:
         self._update_main_title()
-        result = self.results.get(self.selected)
+        main = self.query_one("#main", VerticalScroll)
+        activity = self.query_one("#activity", ActivityLog)
+
+        # Activity pseudo-tab (narrow only): show the live log widget full-height in
+        # place of the main panel. In the wide layout it's the fixed bottom strip.
+        if self._narrow and self.selected == "activity":
+            main.display = False
+            activity.display = True
+            # Drop tree visibility so _sync_focus doesn't park focus on a widget
+            # whose parent (#main) is now hidden.
+            self.query_one("#main-tree", SitemapTree).display = False
+            self._sync_focus()
+            return
+        main.display = True
+        activity.display = not self._narrow
+
         tree = self.query_one("#main-tree", SitemapTree)
         content = self.query_one("#main-content", Static)
+        loading_widget = self.query_one("#main-loading", LoadingIndicator)
+
+        # Server pseudo-tab (narrow only): render the same status table the fixed
+        # Server panel shows, into the main content area.
+        if self.selected == "server":
+            main.border_subtitle = ""
+            tree.display = False
+            has_ctx = self.ctx is not None
+            loading_widget.display = not has_ctx
+            content.display = has_ctx
+            if has_ctx:
+                # 1ch top + left pad so the status table sits clear of the border,
+                # consistent with where the other tabs' content begins.
+                content.update(Padding(render_status(self.ctx, self._cms), (1, 0, 0, 1)))
+            self._sync_focus()
+            return
+
+        result = self.results.get(self.selected)
         loading = result is None
         # Spinner inside the panel until this tab's module completes; swap to the
         # Tree (Sitemap tab) or the Static content once there's a result to render.
-        self.query_one("#main-loading", LoadingIndicator).display = loading
+        loading_widget.display = loading
 
         want_tree = (
             self.selected == "sitemap"
@@ -437,18 +560,36 @@ class WebScannerApp(App):
             if self._tree_result is not result:
                 tree.populate(result.data)
                 self._tree_result = result
-            total = result.data.total
-            if total is not None:
-                self.query_one("#main").border_subtitle = f"{total} Total"
+            if result.data.total is not None:
+                self.query_one("#main").border_subtitle = _sitemap_subtitle(result.data)
         elif result.status is ModuleStatus.FAILED:
             self._set_main(f"[red]failed:[/] {result.error}")
         elif result.status is ModuleStatus.EMPTY:
             msg = "no sitemap found" if self.selected == "sitemap" else "no data found"
             self._set_main(f"[dim]{msg}[/]")
         else:
-            content.update(render_result(self.selected, result.data))
+            avail = self._main_avail()
+            content.update(
+                render_result(self.selected, result.data, narrow=self._narrow, avail=avail)
+            )
+            # When switching from a tab that had #main hidden (Activity), the panel's
+            # content_size isn't known this tick, so the ⅓ column cap was skipped.
+            # Re-render once layout settles so the cap applies.
+            if avail is None:
+                self.call_after_refresh(self._reflow)
         self._sync_focus()
 
+    def _reflow(self) -> None:
+        """Re-render the current tab once the main panel has a known width (used after
+        it was un-hidden, when the first render ran before layout gave it a size)."""
+        if self._main_avail() is not None:
+            self._refresh_main()
+
+    def _refresh_server_tab(self) -> None:
+        """Re-render the Server pseudo-tab as its status data lands (narrow only)."""
+        if self._narrow and self.selected == "server":
+            self._refresh_main()
+
     def _sync_focus(self) -> None:
         """Focus the Sitemap Tree while that tab is up (so ↑/↓/space reach it); drop
         focus otherwise. Never steals focus from the domain input while editing."""
@@ -469,17 +610,28 @@ class WebScannerApp(App):
     def action_prev_tab(self) -> None:
         if self.focused and self.focused.id == "domain":
             return
-        names = self._module_names()
+        names = self._nav_names()
         idx = (names.index(self.selected) - 1) % len(names)
         self._select(names[idx])
 
     def action_next_tab(self) -> None:
         if self.focused and self.focused.id == "domain":
             return
-        names = self._module_names()
+        names = self._nav_names()
         idx = (names.index(self.selected) + 1) % len(names)
         self._select(names[idx])
 
+    def action_select_tab(self, digit: int) -> None:
+        """Jump to the Nth visible tab. ``digit`` is the key pressed: 1..9 select the
+        1st..9th tab, 0 selects the 10th. Ignored while editing the domain input (the
+        digit is typed there instead) or when there's no such tab."""
+        if self.focused and self.focused.id == "domain":
+            return
+        position = 10 if digit == 0 else digit
+        names = self._nav_names()
+        if position <= len(names):
+            self._select(names[position - 1])
+
     def action_rescan(self) -> None:
         if self.ctx is not None:
             self.start_scan(self.ctx.domain)
@@ -537,11 +689,18 @@ class WebScannerApp(App):
         if editing:
             pairs = [("enter", "Scan"), ("esc", "Cancel")]
         elif self.selected == "sitemap":
-            # tree-navigation hints, shown only while the Sitemap tab is up
-            pairs = [
-                ("←/→", "Tab"), ("↑/↓", "Move"), ("enter", "Toggle"),
-                ("space", "All"), ("r", "Rescan"), ("esc", "Edit"),
-            ]
+            # tree-navigation hints, shown only while the Sitemap tab is up. The
+            # narrow layout drops Rescan/Edit to fit the phone-width footer.
+            if self._narrow:
+                pairs = [("↑/↓", "Move"), ("enter", "Toggle"), ("space", "All"), ("←/→", "Tab")]
+            else:
+                pairs = [
+                    ("←/→", "Tab"), ("↑/↓", "Move"), ("enter", "Toggle"),
+                    ("space", "All"), ("r", "Rescan"), ("esc", "Edit"),
+                ]
+        elif self._narrow:
+            # Compact set — the full labels overflow a phone-width footer.
+            pairs = [("←/→", "Tab"), ("r", "Scan"), ("s", "Save"), ("q", "Quit")]
         else:
             pairs = [("q", "Quit"), ("←/→", "Tab"), ("r", "Rescan"), ("s", "Save"), ("esc", "Edit domain")]
         text = "   ".join(f"[b {c}]{k}[/] {label}" for k, label in pairs)

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/ui/app.tcss

@@ -20,9 +20,14 @@ Screen {
     color: white;
 }
 
+/* TabBar is a HorizontalScroll so the selected tab can be scrolled into view when
+   the row overflows a narrow terminal; the scrollbar itself is hidden. */
 #tabs {
     height: 1;
     margin-top: 1;
+    overflow-x: auto;
+    overflow-y: hidden;
+    scrollbar-size: 0 0;
 }
 
 /* Tabs stay dim regardless of scan status; only the selected tab is highlighted. */
@@ -38,6 +43,14 @@ Tab.-selected {
     color: $text;
     text-style: bold;
 }
+/* Activity/Server pseudo tabs: hidden on wide terminals (fixed panels there),
+   shown only in the narrow single-column layout. */
+Tab.-pseudo {
+    display: none;
+}
+.-narrow Tab.-pseudo {
+    display: block;
+}
 
 /* ---- bottom footer row: keybar (left) + progress (right) ---- */
 #footer {
@@ -172,3 +185,26 @@ Tab.-selected {
     padding: 1 1 0 2;   /* space above the table and to the left */
     scrollbar-size: 0 0;   /* keep the bar hidden even if content overflows */
 }
+
+/* ---- narrow (phone-width) layout ----
+   Applied below _NARROW_MAX cols via the `-narrow` class on the Screen (see
+   _apply_narrow). The fixed map + Server panels and the activity strip become tabs,
+   so the grid collapses to a single full-width column and padding is trimmed to buy
+   back horizontal room. */
+.-narrow #topbar {
+    padding: 1 1 0 1;   /* keep the gap above the domain input; trim only below the tabs */
+}
+.-narrow #grid {
+    grid-size: 1 1;
+    grid-columns: 1fr;
+    grid-rows: 1fr;
+}
+/* One visible cell now — drop the row-span so the single column fills the height. */
+.-narrow #left {
+    row-span: 1;
+}
+/* Map + Server become tabs; the activity strip is toggled by tab in Python. */
+.-narrow #map,
+.-narrow #status {
+    display: none;
+}

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/ui/tables.py

@@ -59,27 +59,55 @@ def _smart_token(tok: str) -> str:
     return tok.upper() if tok.lower() in _ACRONYMS else tok.capitalize()
 
 
-def render_result(name: str, data: Any) -> RenderableType:
+def _cap_key_width(width: int | None, avail: int | None) -> int | None:
+    """Cap a first-column width at ~⅓ of the available table width so a long key
+    (a header name, a whois field) can't dominate the row; the column then wraps
+    within that cap. ``avail`` unknown (pre-layout) → the width is left uncapped.
+    ``width`` None means "no content-fit width yet" → take the cap outright."""
+    if avail and avail > 0:
+        cap = max(6, avail // 3)
+        return min(width, cap) if width else cap
+    return width
+
+
+def render_result(name: str, data: Any, narrow: bool = False, avail: int | None = None) -> RenderableType:
     """Render a module's result: multi-column Grid, stacked sub-tables (Sections),
-    or one key/value table."""
+    or one key/value table.
+
+    ``narrow`` collapses wide (>2 column) Grids to their first + last column so a
+    multi-column tab (Tech: Name/…/Version) still reads on a phone-width terminal.
+    ``avail`` is the table's available character width; when known, the first column
+    is capped at ~⅓ of it and wraps rather than running the row wide.
+    """
     if isinstance(data, Grid):
-        return render_grid(data)
+        return render_grid(data, narrow=narrow, avail=avail)
     if isinstance(data, Sections):
         # SEO pins all sub-tables to one fixed first-column width so its four
         # tables (Content/Keywords/Robots/Schema) line up exactly.
-        return render_sections(data, key_width=12 if name == "seo" else None)
+        return render_sections(data, key_width=12 if name == "seo" else None, narrow=narrow, avail=avail)
     mode = "smart" if name in _SMART_LABEL_TABS else "upper"
-    return render_table(data, TAB_HEADERS.get(name), mode=mode)
+    return render_table(data, TAB_HEADERS.get(name), mode=mode, avail=avail)
 
 
-def render_grid(grid: Grid) -> Table:
+def render_grid(grid: Grid, narrow: bool = False, avail: int | None = None) -> 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. When the Grid
     carries ``widths``, every column is pinned to that fixed width (and the table
     stops expanding) so sibling Grids on one tab line up identically.
+
+    ``narrow`` (phone-width terminals) keeps only the first + last column — for
+    Tech that's Name + Version, the two that matter — and pins both to a fixed 50/50
+    ``ratio`` (not content-fit) so every sibling sub-table on the tab lines up
+    identically instead of each fitting its own name lengths.
     """
+    collapsed = narrow and len(grid.columns) > 2
+    if collapsed:
+        keep = [0, len(grid.columns) - 1]
+        columns = [grid.columns[i] for i in keep]
+        rows = [[row[i] for i in keep] for row in grid]
+        grid = Grid(columns, rows)  # widths dropped → columns sized by the ratio below
     widths = grid.widths
     table = Table(
         show_header=True,
@@ -93,7 +121,20 @@ def render_grid(grid: Grid) -> Table:
     )
     for i, col in enumerate(grid.columns):
         w = widths[i] if widths else None
-        if i == 0:
+        if collapsed:
+            # Fixed 50/50 across every sub-table, so the Name/Version columns align
+            # regardless of each group's name lengths.
+            style = KEY_STYLE if i == 0 else MUTED
+            table.add_column(col, style=style, ratio=1, no_wrap=False, overflow="fold")
+        elif i == 0 and w is None:
+            # No fixed widths (e.g. the narrow 2-column Tech): content-fit the Name
+            # column but cap it at ~⅓ and let it wrap, like the key/value tables.
+            name_fit = min(
+                MAX_KEY_WIDTH,
+                max((len(str(row[0])) for row in grid), default=len(col)),
+            )
+            table.add_column(col, style=KEY_STYLE, width=_cap_key_width(name_fit, avail), no_wrap=False, overflow="fold")
+        elif i == 0:
             table.add_column(col, style=KEY_STYLE, width=w, no_wrap=True, overflow="ellipsis")
         else:
             table.add_column(col, style=MUTED, width=w, no_wrap=False, overflow="fold")
@@ -105,13 +146,17 @@ def render_grid(grid: Grid) -> Table:
     return table
 
 
-def render_sections(sections: Sections, key_width: int | None = None) -> Group:
+def render_sections(sections: Sections, key_width: int | None = None, narrow: bool = False, avail: int | None = None) -> Group:
     """Render several titled sub-tables stacked; content-fit sections share one
     first-column width, ratio sections use their fixed proportions. A caller may
-    pass ``key_width`` to pin that shared first-column width explicitly."""
+    pass ``key_width`` to pin that shared first-column width explicitly. ``narrow``
+    is forwarded to any Grid sub-tables (Tech) so they collapse to two columns.
+    ``avail`` caps the shared first-column width at ~⅓ of the table width."""
     if key_width is None:
         widths = [_col1_width(s.data, s.headers, mode="raw") for s in sections if not s.ratio]
         key_width = max([w for w in widths if w], default=None)
+    # Cap the shared key column at ~⅓ so a long field can't widen every sub-table.
+    key_width = _cap_key_width(key_width, avail)
     parts: list[RenderableType] = [Text("")]  # space above the first section title
     for i, sec in enumerate(sections):
         if i:
@@ -121,7 +166,7 @@ def render_sections(sections: Sections, key_width: int | None = None) -> Group:
         parts.append(Text(f" {sec.title.upper()} ", style=SECTION_STYLE))
         if isinstance(sec.data, Grid):
             # e.g. Tech's per-group tables — multi-column, not key/value
-            parts.append(render_grid(sec.data))
+            parts.append(render_grid(sec.data, narrow=narrow, avail=avail))
         else:
             parts.append(
                 render_table(sec.data, sec.headers, mode="raw", spaced=sec.spaced, key_width=key_width, ratio=sec.ratio)
@@ -197,6 +242,7 @@ def render_table(
     spaced: bool = True,
     key_width: int | None = None,
     ratio: tuple[int, int] | None = None,
+    avail: int | None = None,
 ) -> Table:
     """Generic key/value (dict), pair-list, or indexed (list) table.
 
@@ -204,7 +250,8 @@ def render_table(
     ``"smart"`` (Title Case, acronyms upper), or ``"raw"``. ``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).
+    content-fit (e.g. (3, 2) for 60/40). ``avail`` caps the content-fit first column
+    at ~⅓ of the table width (it then wraps instead of running the row wide).
     """
     table = Table(
         show_header=headers is not None,
@@ -218,6 +265,7 @@ def render_table(
     )
     if key_width is None:
         key_width = _col1_width(data, headers, mode)
+    key_width = _cap_key_width(key_width, avail)
 
     if isinstance(data, dict) or _is_pairs(data):
         if isinstance(data, dict):
@@ -234,8 +282,9 @@ def render_table(
             # Table(expand=True) routes all surplus width there and the fixed-width
             # key column stays put — otherwise Rich spreads the surplus across both
             # columns proportionally and the key column widens when values are short
-            # (e.g. an empty Robots/Schema section in the SEO tab).
-            table.add_column(c1, style=KEY_STYLE, width=key_width, no_wrap=True, overflow="ellipsis")
+            # (e.g. an empty Robots/Schema section in the SEO tab). The key column
+            # folds (not ellipsis) so a field wider than its ~⅓ cap wraps in place.
+            table.add_column(c1, style=KEY_STYLE, width=key_width, no_wrap=False, overflow="fold")
             table.add_column(c2, ratio=1, no_wrap=False, overflow="fold")
         _add_spaced(table, rows, spaced)
     elif isinstance(data, (list, tuple)):

{web_scanner-2.2.0 → web_scanner-2.2.2}/webscanner/ui/widgets.py

@@ -6,9 +6,10 @@ from collections import deque
 from datetime import datetime
 
 from rich.markup import escape
+from rich.table import Table
 from rich.text import Text
 from textual.binding import Binding
-from textual.containers import Horizontal
+from textual.containers import Horizontal, HorizontalScroll
 from textual.message import Message
 from textual.widgets import RichLog, Static, Tree
 
@@ -29,10 +30,14 @@ class Tab(Static):
             self.tab_name = tab_name
             super().__init__()
 
-    def __init__(self, name: str, label: str) -> None:
+    def __init__(self, name: str, label: str, pseudo: bool = False) -> None:
         super().__init__(label, id=f"tab-{name}")
         self.tab_name = name
         self.add_class("-pending")
+        # Pseudo tabs (Activity/Server) exist only in the narrow layout; CSS hides
+        # them on wide terminals where those are fixed panels instead.
+        if pseudo:
+            self.add_class("-pseudo")
 
     def set_status(self, status: ModuleStatus) -> None:
         self.remove_class(*_STATUS_CLASSES)
@@ -45,12 +50,28 @@ class Tab(Static):
         self.post_message(self.Clicked(self.tab_name))
 
 
-class TabBar(Horizontal):
-    def __init__(self, modules, **kwargs) -> None:
+class TabBar(HorizontalScroll):
+    """The row of tabs. Scrolls horizontally so the selected tab is always brought
+    into view when the row is wider than the terminal (narrow screens) — Textual's
+    plain ``Horizontal`` would just clip the overflow with no way to reach it.
+
+    ``pseudo`` tabs (Activity/Server) are rendered first but hidden by CSS on wide
+    terminals; they surface only in the narrow layout, where those panels become tabs.
+
+    ``can_focus=False`` keeps single-key nav (↑/↓ for the Sitemap tree, etc.) from
+    being swallowed by the scroll container's own bindings.
+    """
+
+    can_focus = False
+
+    def __init__(self, modules, pseudo: tuple[tuple[str, str], ...] = (), **kwargs) -> None:
         super().__init__(**kwargs)
         self._modules = list(modules)
+        self._pseudo = list(pseudo)
 
     def compose(self):
+        for name, label in self._pseudo:
+            yield Tab(name, label, pseudo=True)
         for module in self._modules:
             yield Tab(module.name, module.label)
 
@@ -58,8 +79,14 @@ class TabBar(Horizontal):
         self.query_one(f"#tab-{name}", Tab).set_status(status)
 
     def set_selected(self, name: str) -> None:
+        selected = None
         for tab in self.query(Tab):
             tab.set_selected(tab.tab_name == name)
+            if tab.tab_name == name:
+                selected = tab
+        # Keep the active tab visible when the row overflows the terminal width.
+        if selected is not None and selected.display:
+            self.scroll_to_widget(selected, animate=False)
 
 
 class MapPanel(Static):
@@ -111,13 +138,15 @@ class StatusPanel(Static):
 class ActivityLog(RichLog):
     """Fixed scan log under the main panel; the newest line is always in view.
 
-    Lines are composed by ``activity.py`` — this only stamps the time, paints the
-    body, and decides how a too-long line is cut, so the wording stays testable
-    without an app.
+    Lines are composed by ``activity.py`` — this only stamps the time and paints the
+    body, so the wording stays testable without an app.
 
-    Each line is written as a ``no_wrap`` / ``overflow="ellipsis"`` Text at the
-    panel's exact width, so it's truncated with "…" at the panel edge and a wider
-    terminal reveals more of it. Nothing is pre-cropped to an assumed width.
+    Each line is a two-column ``Table.grid``: a fixed-width timestamp column and a
+    wrapping body column. When the body is wider than the panel it **wraps** (word
+    boundaries), and the grid's second column keeps every continuation line indented
+    past the timestamp — a hanging indent aligned under the first body character. The
+    grid is rendered at the panel's exact width, so a wider terminal simply fits more
+    on each line before wrapping.
 
     ``can_focus=False`` is load-bearing, not tidiness: RichLog inherits
     ScrollableContainer's ungated up/down bindings, so a focused log would swallow
@@ -133,35 +162,38 @@ class ActivityLog(RichLog):
 
     def __init__(self, **kwargs) -> None:
         # min_width=0: the 78 default renders every write at >=78 cells, overflowing
-        # a narrower panel. wrap=True: with wrap=False, RichLog forces
-        # overflow="ignore" on Text and the tail vanishes with no ellipsis.
+        # a narrower panel.
         super().__init__(markup=True, wrap=True, min_width=0, max_lines=self._MAX_LINES, **kwargs)
         # RichLog renders to strips at write time and never re-renders, so keep the
-        # markup to replay when the width changes.
-        self._entries: deque[str] = deque(maxlen=self._MAX_LINES)
+        # (stamp, body) markup pairs to replay when the width changes.
+        self._entries: deque[tuple[str, str]] = deque(maxlen=self._MAX_LINES)
         self._rendered_width: int | None = None
 
     def add(self, body: str) -> None:
         """Write one line, stamped with a muted [HH:MM:SS]."""
-        stamp = escape(f"[{datetime.now():%H:%M:%S}]")
-        markup = f"[{MUTED}]{stamp}[/] [{BODY}]{body}[/]"
-        self._entries.append(markup)
-        self._write(markup)
-
-    def _write(self, markup: str) -> None:
-        text = Text.from_markup(markup)
-        text.no_wrap = True
-        text.overflow = "ellipsis"
+        stamp = f"[{MUTED}]{escape(f'[{datetime.now():%H:%M:%S}]')}[/]"
+        body_markup = f"[{BODY}]{body}[/]"
+        self._entries.append((stamp, body_markup))
+        self._write(stamp, body_markup)
+
+    def _write(self, stamp: str, body: str) -> None:
+        # Two columns: the timestamp at a fixed width (its 10 chars + a 1-cell gap),
+        # then the body in a flexible column that wraps. The grid keeps the body
+        # column left edge constant, so wrapped continuation lines hang-indent under
+        # the first body character rather than sliding back under the timestamp.
+        grid = Table.grid(expand=True)
+        grid.add_column(width=11, no_wrap=True)
+        grid.add_column(ratio=1)
+        grid.add_row(Text.from_markup(stamp), Text.from_markup(body))
         # Explicit width, because RichLog's own sizing measures against
         # `app.console`, which is a plain 80 columns regardless of how wide the app
-        # actually is — every line would ellipsise at 80 on a wider terminal. Passing
-        # width bypasses measure/shrink/min_width entirely. Width 0 means we aren't
-        # laid out yet: let RichLog defer the write, and on_resize replays it.
+        # actually is — the body would wrap at 80 on a wider terminal. Width 0 means
+        # we aren't laid out yet: let RichLog defer the write, and on_resize replays it.
         width = self.scrollable_content_region.width
         if width:
-            self.write(text, width=width)
+            self.write(grid, width=width)
         else:
-            self.write(text)
+            self.write(grid)
 
     def clear(self) -> "ActivityLog":
         self._entries.clear()
@@ -178,13 +210,13 @@ class ActivityLog(RichLog):
         if not self._entries:
             return
         # RichLog renders to strips at write time and never re-renders, so replay at
-        # the new width: a wider terminal reveals more of each line, a narrower one
-        # re-ellipsises. Also fixes the first sizing, where deferred lines were
-        # rendered by RichLog without our explicit width.
+        # the new width: a wider terminal fits more before wrapping, a narrower one
+        # re-wraps to more lines. Also fixes the first sizing, where deferred lines
+        # were rendered by RichLog without our explicit width.
         entries = list(self._entries)
         super().clear()
-        for markup in entries:
-            self._write(markup)
+        for stamp, body in entries:
+            self._write(stamp, body)
 
 
 class SitemapTree(Tree):
@@ -206,6 +238,17 @@ class SitemapTree(Tree):
     BINDINGS = [
         Binding("enter", "toggle_node", "Toggle", show=False),
         Binding("space", "toggle_all", "Expand/collapse all", show=False),
+        # Tree's base (ScrollView) binds left/right to horizontal scroll, which would
+        # swallow the app's ←/→ tab navigation whenever a long URL overflows the panel.
+        # Redirect them to the app so ←/→ always changes tab from the Sitemap too.
+        Binding("left", "prev_tab", show=False),
+        Binding("right", "next_tab", show=False),
+        # The tree is height:auto inside the #main VerticalScroll, so it has nothing
+        # of its own to scroll — its inherited page up/down bindings would just no-op
+        # and swallow the keys. Redirect them to #main so paging works like every
+        # other tab.
+        Binding("pageup", "page_main_up", show=False),
+        Binding("pagedown", "page_main_down", show=False),
     ]
 
     #: Textual gives the expand/collapse chevron no component class of its own — it
@@ -270,6 +313,18 @@ class SitemapTree(Tree):
         if 0 <= index < len(self._leaf_urls):
             self.app.open_url(self._leaf_urls[index])
 
+    def action_prev_tab(self) -> None:
+        self.app.action_prev_tab()
+
+    def action_next_tab(self) -> None:
+        self.app.action_next_tab()
+
+    def action_page_main_up(self) -> None:
+        self.app.action_scroll_main_up()
+
+    def action_page_main_down(self) -> None:
+        self.app.action_scroll_main_down()
+
     def action_toggle_all(self) -> None:
         branches = self._branches()
         if not branches:

web_scanner-2.2.0/webscanner/cli.py

@@ -1,24 +0,0 @@
-"""Console entry point for the ``webscan`` command.
-
-    webscan example.com
-    python -m webscanner example.com
-"""
-
-from __future__ import annotations
-
-import sys
-
-from webscanner.helpers import is_valid_url
-from webscanner.ui.app import WebScannerApp
-
-
-def main() -> None:
-    target = sys.argv[1].strip() if len(sys.argv) > 1 else None
-    if target and not is_valid_url(target):
-        print(f"[!] Not a valid target: {target}")
-        raise SystemExit(1)
-    WebScannerApp(target).run()
-
-
-if __name__ == "__main__":
-    main()