web-scanner 2.2.1__tar.gz → 2.2.3__tar.gz

{web_scanner-2.2.1 → web_scanner-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web-scanner
-Version: 2.2.1
+Version: 2.2.3
 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
@@ -69,9 +69,7 @@ a server-status panel that stay pinned in place.
 resolvers for blocklist checks, the system `whois`, and stdlib `ssl`/`socket`. Country
 borders are embedded (Natural Earth), so even the map needs no tile service.
 
-![WebScanner — DNS tab](https://raw.githubusercontent.com/iamramizk/web-scanner/main/.github/screenshot-v2-1.png)
-
-![WebScanner — Security tab](https://raw.githubusercontent.com/iamramizk/web-scanner/main/.github/screenshot-v2-2.png)
+![WebScanner — DNS tab, with the responsive narrow layout inset](https://raw.githubusercontent.com/iamramizk/web-scanner/main/.github/screenshot-v2-2-2.png)
 
 ## Contents
 
@@ -130,7 +128,11 @@ Alongside the tabs, three fixed panels:
 - **Server** — online status and response time, the final URL after redirects, IP,
   geolocation, ISP, AS, hosting provider and detected CMS (name and version). When many
   sites share the server's IP, it flags the address as shared and counts how many distinct
-  domains resolve to it (via a free reverse-IP lookup).
+  domains resolve to it (via a free reverse-IP lookup, [hackertarget](https://hackertarget.com/),
+  rate-limited to 50 requests/day).
+
+The layout is **responsive**: on a narrow terminal it collapses to a single full-width
+column and the map, Server and Activity panels fold into their own tabs.
 
 Requests to the site being scanned wear a **coherent desktop-Chrome identity** — a real
 User-Agent plus the headers Chrome actually sends beside it — picked once per scan and
@@ -174,11 +176,19 @@ webscan example.com
 You can also run it as a module (`python -m webscanner example.com`), or from a source
 checkout without installing (`python app.py example.com`).
 
-Press `s` inside the app to save every tab to CSV. When installed, results are written to a
-`./<domain>_<timestamp>/` folder in your current directory.
+Once a scan finishes you can stay in the app: press `r` to rescan the same domain, or `esc`
+to edit the domain and scan a different one — no need to restart.
+
+Press `s` to save every tab to CSV (plus a `server.csv` for the fixed Server panel, which
+has no tab of its own). Files go into a `<domain>_<timestamp>/` folder — under `output/`
+when running from a source checkout, or straight in your current directory when installed.
 
 ## Updating
 
+The app checks PyPI in the background once a day and, when a newer release is out, marks the
+version in the footer with an orange dot and adds a line to the Activity Log — so you'll know
+when it's worth upgrading.
+
 ```bash
 pipx upgrade web-scanner
 ```
@@ -195,6 +205,8 @@ pipx install --force git+https://github.com/iamramizk/web-scanner
 | Key              | Action                                                              |
 | ---------------- | ------------------------------------------------------------------- |
 | `←` / `→` `Tab`  | Switch tabs                                                         |
+| `1`–`9` `0`      | Jump straight to the Nth tab (`0` = 10th)                           |
+| `PgUp` / `PgDn`  | Scroll the main panel up / down                                     |
 | `+` / `-`        | Zoom the country map in / out                                       |
 | `↑` / `↓` `enter`| Navigate the Sitemap tree (`space` expands/collapses all)          |
 | `r`              | Rescan                                                              |

{web_scanner-2.2.1 → web_scanner-2.2.3}/README.md

@@ -19,9 +19,7 @@ a server-status panel that stay pinned in place.
 resolvers for blocklist checks, the system `whois`, and stdlib `ssl`/`socket`. Country
 borders are embedded (Natural Earth), so even the map needs no tile service.
 
-![WebScanner — DNS tab](https://raw.githubusercontent.com/iamramizk/web-scanner/main/.github/screenshot-v2-1.png)
-
-![WebScanner — Security tab](https://raw.githubusercontent.com/iamramizk/web-scanner/main/.github/screenshot-v2-2.png)
+![WebScanner — DNS tab, with the responsive narrow layout inset](https://raw.githubusercontent.com/iamramizk/web-scanner/main/.github/screenshot-v2-2-2.png)
 
 ## Contents
 
@@ -80,7 +78,11 @@ Alongside the tabs, three fixed panels:
 - **Server** — online status and response time, the final URL after redirects, IP,
   geolocation, ISP, AS, hosting provider and detected CMS (name and version). When many
   sites share the server's IP, it flags the address as shared and counts how many distinct
-  domains resolve to it (via a free reverse-IP lookup).
+  domains resolve to it (via a free reverse-IP lookup, [hackertarget](https://hackertarget.com/),
+  rate-limited to 50 requests/day).
+
+The layout is **responsive**: on a narrow terminal it collapses to a single full-width
+column and the map, Server and Activity panels fold into their own tabs.
 
 Requests to the site being scanned wear a **coherent desktop-Chrome identity** — a real
 User-Agent plus the headers Chrome actually sends beside it — picked once per scan and
@@ -124,11 +126,19 @@ webscan example.com
 You can also run it as a module (`python -m webscanner example.com`), or from a source
 checkout without installing (`python app.py example.com`).
 
-Press `s` inside the app to save every tab to CSV. When installed, results are written to a
-`./<domain>_<timestamp>/` folder in your current directory.
+Once a scan finishes you can stay in the app: press `r` to rescan the same domain, or `esc`
+to edit the domain and scan a different one — no need to restart.
+
+Press `s` to save every tab to CSV (plus a `server.csv` for the fixed Server panel, which
+has no tab of its own). Files go into a `<domain>_<timestamp>/` folder — under `output/`
+when running from a source checkout, or straight in your current directory when installed.
 
 ## Updating
 
+The app checks PyPI in the background once a day and, when a newer release is out, marks the
+version in the footer with an orange dot and adds a line to the Activity Log — so you'll know
+when it's worth upgrading.
+
 ```bash
 pipx upgrade web-scanner
 ```
@@ -145,6 +155,8 @@ pipx install --force git+https://github.com/iamramizk/web-scanner
 | Key              | Action                                                              |
 | ---------------- | ------------------------------------------------------------------- |
 | `←` / `→` `Tab`  | Switch tabs                                                         |
+| `1`–`9` `0`      | Jump straight to the Nth tab (`0` = 10th)                           |
+| `PgUp` / `PgDn`  | Scroll the main panel up / down                                     |
 | `+` / `-`        | Zoom the country map in / out                                       |
 | `↑` / `↓` `enter`| Navigate the Sitemap tree (`space` expands/collapses all)          |
 | `r`              | Rescan                                                              |

{web_scanner-2.2.1 → web_scanner-2.2.3}/webscanner/__init__.py

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

web_scanner-2.2.3/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.1 → web_scanner-2.2.3}/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.1 → web_scanner-2.2.3}/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.1 → web_scanner-2.2.3}/webscanner/modules/dns.py

@@ -151,6 +151,12 @@ class DnsModule(ScanModule):
                     out[rtype] = res
             return out
 
+        async def www_cname() -> list[str]:
+            # The apex almost never has a CNAME (forbidden alongside its SOA/NS), so
+            # the standard CNAME lookup above is usually empty. Hosting providers put
+            # the CNAME on `www.` instead — surface it when the apex has none.
+            return await asyncio.to_thread(pydig.query, f"www.{domain}", "CNAME")
+
         async def dmarc() -> list[str]:
             txt = await asyncio.to_thread(pydig.query, f"_dmarc.{domain}", "TXT")
             return [t for t in txt if "dmarc1" in t.lower()]
@@ -159,12 +165,17 @@ class DnsModule(ScanModule):
             txt = await asyncio.to_thread(pydig.query, f"{sel}._domainkey.{domain}", "TXT")
             return sel if txt and _is_dkim(txt) else None
 
-        out, dmarc_records, dkim_hits = await asyncio.gather(
+        out, www, dmarc_records, dkim_hits = await asyncio.gather(
             asyncio.to_thread(records),
+            www_cname(),
             dmarc(),
             asyncio.gather(*(dkim_selector(s) for s in DKIM_SELECTORS)),
         )
 
+        # Show the www CNAME when the apex has none (the common hosting-provider case).
+        if www and "CNAME" not in out:
+            out["CNAME (www)"] = www
+
         if dmarc_records:
             out["DMARC"] = dmarc_records
         found = [s for s in dkim_hits if s]

{web_scanner-2.2.1 → web_scanner-2.2.3}/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.1 → web_scanner-2.2.3}/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.1 → web_scanner-2.2.3}/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 ..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:
@@ -340,7 +366,8 @@ def waf(result: ModuleResult) -> str | None:
 
 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."""
+    line, only when a newer version was actually found — see net/version_check.py.
+    Complements (does not replace) the status-bar version dot."""
     return f"Update: [{BLUE}]v{_esc(latest)} available[/] — run `pipx upgrade web-scanner`."
 
 

{web_scanner-2.2.1 → web_scanner-2.2.3}/webscanner/ui/app.py

@@ -25,10 +25,11 @@ from textual.message import Message
 from textual.widgets import Input, LoadingIndicator, Static
 
 from .. import __version__
+from ..colors import 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, render_status
@@ -38,6 +39,11 @@ from .widgets import ActivityLog, MapPanel, SitemapTree, StatusPanel, TabBar, Ta
 _BAR_WIDTH = 22
 _BAR_DIM = "grey30"
 
+#: The status-bar version dot is shown only when a newer PyPI release is available
+#: (`_version_status == "outdated"`; see net/version_check.py) — an orange `•`. The
+#: initial/unknown and up-to-date states show no dot, keeping the footer quiet until
+#: there's something to say.
+
 #: 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
@@ -50,19 +56,29 @@ _PSEUDO_NAMES = frozenset(name for name, _ in _PSEUDO_TABS)
 _PSEUDO_LABELS = {name: label for name, label in _PSEUDO_TABS}
 
 
+#: Wappalyzer categories that name the CMS, in priority order. ``CMS`` is the reliable
+#: signal (the broader "Content" *group* also covers non-CMS tools). ``Page builders``
+#: is a fallback for standalone site builders that carry no ``CMS`` tag (Webflow, Wix,
+#: Squarespace, Duda, Framer). It is checked *only after* ``CMS`` comes up empty, because
+#: the same category also holds WordPress *plugins* that are not the CMS (Elementor, Divi,
+#: WPBakery) — on those sites Wappalyzer tags WordPress ``CMS`` and the first pass wins.
+_CMS_CATEGORIES = ("CMS", "Page builders")
+
+
 def _cms_from_tech(data: object) -> tuple[str, str | None] | None:
     """The CMS (name, version) from the Tech result, or ``None`` if none detected.
 
     The Tech result is a ``Sections`` of per-group ``Grid``s whose rows are
-    ``[name, categories, confidence, version]`` (see ``modules/tech.py``). A CMS is
-    any tech Wappalyzer tags with the ``CMS`` category — the reliable signal (the
-    broader "Content" *group* also covers non-CMS tools). ``categories`` is a
-    ", "-joined string; version is ``"-"`` when unknown → returned as ``None``.
+    ``[name, categories, confidence, version]`` (see ``modules/tech.py``). A CMS is any
+    tech Wappalyzer tags with a category in ``_CMS_CATEGORIES`` — tried in order, so a
+    real ``CMS`` hit always beats a ``Page builders`` one across the whole result.
+    ``categories`` is a ", "-joined string; version is ``"-"`` when unknown → ``None``.
     """
-    for section in data or []:
-        for name, categories, _confidence, version in section.data:
-            if "CMS" in [c.strip() for c in str(categories).split(",")]:
-                return name, (version if version and version != "-" else None)
+    for target in _CMS_CATEGORIES:
+        for section in data or []:
+            for name, categories, _confidence, version in section.data:
+                if target in [c.strip() for c in str(categories).split(",")]:
+                    return name, (version if version and version != "-" else None)
     return None
 
 
@@ -111,12 +127,12 @@ def _same_cms(left: str, right: str) -> bool:
 def _detect_cms(tech_data: object, html: str | None) -> tuple[str, str | None] | None:
     """The CMS (name, version) for the Server panel, or ``None`` if nothing detected.
 
-    Wappalyzer's ``CMS`` category is the primary signal — it's curated, so it won't
-    mistake a page builder or analytics tag for the CMS. The ``<meta name="generator">``
-    tag covers the two cases it misses: a CMS Wappalyzer has no fingerprint for (e.g.
-    Sitefinity, Webflow) → the generator is used outright; and a CMS it detects but
-    can't version → the generator supplies the version, but only when it names the
-    *same* product, so an "Elementor 3.x" generator can't hijack a "WordPress" hit.
+    ``_cms_from_tech`` is the primary signal (Wappalyzer's ``CMS`` category, then a
+    ``Page builders`` fallback — see there). The ``<meta name="generator">`` tag covers
+    the two cases it misses: a CMS Wappalyzer has no fingerprint for at all (e.g.
+    Sitefinity) → the generator is used outright; and a CMS it detects but can't version
+    → the generator supplies the version, but only when it names the *same* product, so
+    an "Elementor 3.x" generator can't hijack a "WordPress" hit.
     """
     tech = _cms_from_tech(tech_data)
     generators = _generators(html)
@@ -133,6 +149,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."""
 
@@ -146,9 +176,15 @@ 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:
+    ``status`` is one of ``"unknown"`` / ``"latest"`` / ``"outdated"`` — it drives
+    the colour of the status-bar version dot. ``latest`` is the newer version string
+    when ``status == "outdated"`` (else None) — used for the Activity Log line.
+    """
+
+    def __init__(self, status: str, latest: str | None) -> None:
+        self.status = status
         self.latest = latest
         super().__init__()
 
@@ -212,8 +248,12 @@ 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.
+        # 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"
+        # …and, when a newer release exists, an Activity Log line announced once after
+        # whichever finishes last: the scan or the check itself (the dot is not enough
+        # on its own — the log line spells out the upgrade command).
         self._update_available: str | None = None
         self._version_checked = False
         self._update_announced = False
@@ -246,6 +286,9 @@ class WebScannerApp(App):
         self.query_one("#tabs", TabBar).set_selected(self.selected)
         # 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(
@@ -288,15 +331,22 @@ class WebScannerApp(App):
         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, latest))
 
     def on_version_checked(self, message: VersionChecked) -> None:
+        self._version_status = message.status
         self._update_available = message.latest
         self._version_checked = True
+        self._refresh_version()
         self._maybe_announce_update()
 
     def _maybe_announce_update(self) -> None:
+        """Append the "update available" Activity Log line once, after the scan's own
+        closing line — so it lands as the last message. Gated on the scan being done
+        (otherwise it would jump ahead of the module lines) and on a newer release
+        actually existing; the check may finish before or after the scan, so both
+        on_version_checked and on_scan_finished call this."""
         if (
             self._update_announced
             or self._scanning
@@ -309,6 +359,16 @@ class WebScannerApp(App):
             activity.update_available(self._update_available)
         )
 
+    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
+        # Only show the dot when an update is available (hide the initial blue /
+        # up-to-date green states) — a quiet footer until there's something to say.
+        dot = f" [{ORANGE}]•[/]" if self._version_status == "outdated" else ""
+        self.query_one("#progress", Static).update(f"v{__version__}{dot}")
+
     # ---- scanning ---------------------------------------------------------
 
     def start_scan(self, target: str) -> None:
@@ -415,14 +475,14 @@ class WebScannerApp(App):
                 self.completed, self.failed, total, time.monotonic() - self._scan_start
             )
         )
-        self.query_one("#progress", Static).update(f"v{__version__}")
+        self._refresh_version()
         self._maybe_announce_update()
 
     # ---- progress line ----------------------------------------------------
 
     def _update_progress(self) -> None:
         """Draw a determinate progress bar (blue = done, grey = remaining) with the
-        percentage and n/total count in white, right-aligned on the footer row."""
+        percentage in white, right-aligned on the footer row."""
         if not self._scanning:
             return
         total = len(self.modules)
@@ -431,7 +491,7 @@ class WebScannerApp(App):
         blue = self.current_theme.primary
         bar = f"[{blue}]{'━' * filled}[/][{_BAR_DIM}]{'━' * (_BAR_WIDTH - filled)}[/]"
         self.query_one("#progress", Static).update(
-            f"{bar} [white]{round(frac * 100)}% {self.completed}/{total}[/]"
+            f"{bar} [white]{round(frac * 100)}%[/]"
         )
 
     # ---- tab selection ----------------------------------------------------
@@ -542,9 +602,8 @@ 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:
@@ -653,11 +712,19 @@ class WebScannerApp(App):
     def action_zoom_out(self) -> None:
         self.query_one("#map", MapPanel).zoom_by(-1)
 
+    def _page_target(self):
+        """The widget page-up/down should scroll. Usually the main panel, but the
+        Activity pseudo-tab (narrow only) shows the #activity RichLog full-height in
+        #main's place, so page keys must scroll that instead — #main is hidden there."""
+        if self._narrow and self.selected == "activity":
+            return self.query_one("#activity", ActivityLog)
+        return self.query_one("#main", VerticalScroll)
+
     def action_scroll_main_up(self) -> None:
-        self.query_one("#main", VerticalScroll).scroll_page_up()
+        self._page_target().scroll_page_up()
 
     def action_scroll_main_down(self) -> None:
-        self.query_one("#main", VerticalScroll).scroll_page_down()
+        self._page_target().scroll_page_down()
 
     def on_input_submitted(self, message: Input.Submitted) -> None:
         target = message.value.strip()
@@ -685,6 +752,10 @@ class WebScannerApp(App):
             # 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")]
+            # PgUp/Dn scrolls #main — only shown wide; the narrow footer has no room.
+            pairs = [
+                ("q", "Quit"), ("←/→", "Tab"), ("Pg↑/↓", "Scroll"),
+                ("r", "Rescan"), ("s", "Save"), ("esc", "Edit domain"),
+            ]
         text = "   ".join(f"[b {c}]{k}[/] {label}" for k, label in pairs)
         self.query_one("#keybar", Static).update(text)

{web_scanner-2.2.1 → web_scanner-2.2.3}/webscanner/ui/tables.py

@@ -37,8 +37,9 @@ TAB_HEADERS: dict[str, tuple[str, str]] = {
 MAX_KEY_WIDTH = 34
 
 # Tabs whose key column is smart-cased (Title Case, acronyms kept upper) instead of
-# ALL CAPS. dns stays "upper" — its keys are record types (AAAA/CNAME/DNSKEY/DMARC).
-_SMART_LABEL_TABS = {"whois", "ssl", "headers"}
+# ALL CAPS. dns is smart too — its keys are mostly record-type acronyms (kept upper via
+# _ACRONYMS), but derived rows read better Title-cased ("Email Spoofing", "CNAME (www)").
+_SMART_LABEL_TABS = {"dns", "whois", "ssl", "headers"}
 
 # Tokens that render upper-case rather than Title-cased. Lowercase keys. Only needs
 # the acronyms that actually appear as key tokens in the smart-cased tabs — NOT an
@@ -49,6 +50,8 @@ _ACRONYMS: frozenset[str] = frozenset({
     "id", "url", "iana", "whois", "dnssec",
     # ssl
     "cn", "san", "ssl", "tls",
+    # dns record types (keep upper on the smart-cased dns tab)
+    "a", "aaaa", "ns", "cname", "soa", "mx", "txt", "caa", "ds", "dnskey",
     # headers / general web acronyms
     "xss", "csp", "hsts", "cors", "www", "ua", "md5", "ip", "dns",
     "http", "https", "uri", "api", "spf", "dkim", "dmarc",

web_scanner-2.2.1/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()