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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web-scanner
-Version: 2.2.0
+Version: 2.2.1
 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.1}/webscanner/__init__.py

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

{web_scanner-2.2.0 → web_scanner-2.2.1}/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
@@ -30,13 +31,24 @@ from ..modules import all_modules
 from ..net.version_check import check_for_update
 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"
 
+#: 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.
@@ -166,6 +178,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 +200,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
@@ -204,7 +223,7 @@ class WebScannerApp(App):
     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 +244,8 @@ 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)
         # 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,6 +256,37 @@ 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))
@@ -314,12 +364,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 +403,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()
 
@@ -386,17 +439,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 +478,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"
@@ -446,9 +551,28 @@ class WebScannerApp(App):
             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 +593,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 +672,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.1}/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.1}/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.1}/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: