capstan 1.0.0__tar.gz

capstan-1.0.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julien Hadley Jack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

capstan-1.0.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: capstan
+Version: 1.0.0
+Summary: A webhook inspector for local development
+Author: Julien Hadley Jack
+Author-email: Julien Hadley Jack <git@jlhj.de>
+License-Expression: MIT
+License-File: LICENSE.txt
+Requires-Dist: aiohttp>=3.13.5
+Requires-Dist: cyclopts>=4.10.0
+Requires-Dist: textual>=8.1.1
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Capstan: The Webhook Inspector
+
+<!-- [[[cog
+from pathlib import Path
+from scripts.cog_readme import copy_image
+copy_image(
+  Path("tests/__snapshots__/test_tui_app/test_snapshot_populated.raw"),
+  Path("docs/screenshot.svg"),
+)
+]]] -->
+<!-- file checksum: 7122778bb8772c8540cb272658e2a897cc33e7313bc034f4884beaa1be9bd497 -->
+![](docs/screenshot.svg)
+<!-- [[[end]]] -->
+
+**Capstan** is a modern, lightweight, and terminal-based webhook inspector for local development. It provides a TUI (
+Terminal User Interface) to monitor and inspect incoming HTTP requests, making it the perfect companion for debugging
+webhooks and API integrations without leaving your terminal.
+
+## Features
+
+- **Overview**: Quick view of method, path, host, and timestamp.
+- **Headers & Cookies**: Complete breakdown of all request headers and cookies.
+- **Query Parameters**: Easy-to-read table of all URL parameters.
+- **Body Analysis**:
+    - **Syntax Highlighting**: Built-in support for JSON, XML, and more.
+    - **Hexdump**: Automatic fallback to a polished hexdump for binary or unknown content.
+
+Capstan is designed to be a simple and lightweight tool. As such, it does **not** support:
+
+- **Persistence**: Captured requests are stored in-memory and are lost when the application is closed.
+- **HTTPS/SSL**: The local server only supports HTTP. Use a tunnel like `ngrok` if you need to receive webhooks from
+  HTTPS sources or from the internet.
+- **Dynamic Responses**: It returns a static response (status, body, headers) for all requests.
+- **Request Replay**: There is no functionality to "replay" or "resend" captured requests.
+
+[mitmproxy](https://www.mitmproxy.org/) can be used instead should those advanced features be needed.
+
+## Installation
+
+You can install Capstan using `uv` (recommended) :
+
+```bash
+uv tool install capstan
+```
+
+Alternatively, you could install it with `pipx`:
+
+```bash
+pipx install capstan
+```
+
+## Quick Start
+
+Simply run `capstan` to start the inspector:
+
+```bash
+capstan
+```
+
+By default, Capstan will start a server on `http://127.0.0.1:8080`.
+You can now send requests to this address (or any path under it),
+and they will appear in the TUI.
+
+You can send then HTTP requests to that address with arbitrary paths. Example:
+
+```bash
+curl -X POST http://127.0.0.1:8080/test-webhook \
+     -H "Content-Type: application/json" \
+     -d '{"event": "user_signup", "user_id": 123}'
+```
+
+## Usage
+
+See the help documentation for more information:
+
+<!-- [[[cog
+from pathlib import Path
+from scripts.cog_readme import run_command
+run_command("capstan --help")
+]]] -->
+```bash
+$ capstan --help
+Usage: capstan COMMAND [OPTIONS]
+
+A webhook inspector for local development.
+
+╭─ Commands ───────────────────────────────────────────────────────────────────╮
+│ --help (-h)           Display this message and exit.                         │
+│ --install-completion  Install shell completion for this application.         │
+│ --version             Display application version.                           │
+╰──────────────────────────────────────────────────────────────────────────────╯
+╭─ Parameters ─────────────────────────────────────────────────────────────────╮
+│ --host    The listen address for the endpoint [default: 127.0.0.1]           │
+│ --port    The port for the endpoint [default: 8080]                          │
+│ --status  The response status code for the webhook [default: 201]            │
+╰──────────────────────────────────────────────────────────────────────────────╯
+```
+<!-- [[[end]]] -->

capstan-1.0.0/README.md

@@ -0,0 +1,98 @@
+# Capstan: The Webhook Inspector
+
+<!-- [[[cog
+from pathlib import Path
+from scripts.cog_readme import copy_image
+copy_image(
+  Path("tests/__snapshots__/test_tui_app/test_snapshot_populated.raw"),
+  Path("docs/screenshot.svg"),
+)
+]]] -->
+<!-- file checksum: 7122778bb8772c8540cb272658e2a897cc33e7313bc034f4884beaa1be9bd497 -->
+![](docs/screenshot.svg)
+<!-- [[[end]]] -->
+
+**Capstan** is a modern, lightweight, and terminal-based webhook inspector for local development. It provides a TUI (
+Terminal User Interface) to monitor and inspect incoming HTTP requests, making it the perfect companion for debugging
+webhooks and API integrations without leaving your terminal.
+
+## Features
+
+- **Overview**: Quick view of method, path, host, and timestamp.
+- **Headers & Cookies**: Complete breakdown of all request headers and cookies.
+- **Query Parameters**: Easy-to-read table of all URL parameters.
+- **Body Analysis**:
+    - **Syntax Highlighting**: Built-in support for JSON, XML, and more.
+    - **Hexdump**: Automatic fallback to a polished hexdump for binary or unknown content.
+
+Capstan is designed to be a simple and lightweight tool. As such, it does **not** support:
+
+- **Persistence**: Captured requests are stored in-memory and are lost when the application is closed.
+- **HTTPS/SSL**: The local server only supports HTTP. Use a tunnel like `ngrok` if you need to receive webhooks from
+  HTTPS sources or from the internet.
+- **Dynamic Responses**: It returns a static response (status, body, headers) for all requests.
+- **Request Replay**: There is no functionality to "replay" or "resend" captured requests.
+
+[mitmproxy](https://www.mitmproxy.org/) can be used instead should those advanced features be needed.
+
+## Installation
+
+You can install Capstan using `uv` (recommended) :
+
+```bash
+uv tool install capstan
+```
+
+Alternatively, you could install it with `pipx`:
+
+```bash
+pipx install capstan
+```
+
+## Quick Start
+
+Simply run `capstan` to start the inspector:
+
+```bash
+capstan
+```
+
+By default, Capstan will start a server on `http://127.0.0.1:8080`.
+You can now send requests to this address (or any path under it),
+and they will appear in the TUI.
+
+You can send then HTTP requests to that address with arbitrary paths. Example:
+
+```bash
+curl -X POST http://127.0.0.1:8080/test-webhook \
+     -H "Content-Type: application/json" \
+     -d '{"event": "user_signup", "user_id": 123}'
+```
+
+## Usage
+
+See the help documentation for more information:
+
+<!-- [[[cog
+from pathlib import Path
+from scripts.cog_readme import run_command
+run_command("capstan --help")
+]]] -->
+```bash
+$ capstan --help
+Usage: capstan COMMAND [OPTIONS]
+
+A webhook inspector for local development.
+
+╭─ Commands ───────────────────────────────────────────────────────────────────╮
+│ --help (-h)           Display this message and exit.                         │
+│ --install-completion  Install shell completion for this application.         │
+│ --version             Display application version.                           │
+╰──────────────────────────────────────────────────────────────────────────────╯
+╭─ Parameters ─────────────────────────────────────────────────────────────────╮
+│ --host    The listen address for the endpoint [default: 127.0.0.1]           │
+│ --port    The port for the endpoint [default: 8080]                          │
+│ --status  The response status code for the webhook [default: 201]            │
+╰──────────────────────────────────────────────────────────────────────────────╯
+```
+<!-- [[[end]]] -->

capstan-1.0.0/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "capstan"
+version = "1.0.0"
+description = "A webhook inspector for local development"
+readme = "README.md"
+authors = [
+    { name = "Julien Hadley Jack", email = "git@jlhj.de" }
+]
+license = "MIT"
+license-files = [
+    "LICENSE.txt",
+]
+requires-python = ">=3.11"
+dependencies = [
+    "aiohttp>=3.13.5",
+    "cyclopts>=4.10.0",
+    "textual>=8.1.1",
+]
+
+[project.scripts]
+capstan = "capstan.cli:app"
+
+[build-system]
+requires = ["uv_build>=0.11.1,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+build = [
+    "python-semantic-release>=10.5.3",
+]
+dev = [
+    "cogapp>=3.6.0",
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov>=7.0.0",
+    "pytest-github-report>=0.0.1",
+    "pytest-textual-snapshot>=1.0.0",
+    "ruff>=0.15.7",
+    "textual-dev>=1.8.0",
+]
+
+[tool.uv]
+required-version = ">=0.9.6"
+
+[tool.ruff]
+line-length = 120
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+build_command = """
+    uv run cog -r README.md
+    uv lock --upgrade-package "$PACKAGE_NAME"
+    git add README.md uv.lock
+    uv build
+"""
+
+[tool.semantic_release.changelog]
+exclude_commit_patterns = [
+    '''chore(?:\([^)]*?\))?: .+''',
+    '''ci(?:\([^)]*?\))?: .+''',
+    '''refactor(?:\([^)]*?\))?: .+''',
+    '''style(?:\([^)]*?\))?: .+''',
+    '''test(?:\([^)]*?\))?: .+''',
+    '''docs(?:\([^)]*?\))?: .+''',
+    '''build(?:\([^)]*?\))?: .+''',
+    '''build\((?!deps\): .+)''',
+]
+
+[semantic_release.changelog.default_templates]
+changelog_file = "CHANGELOG.md"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+addopts = ["--snapshot-patch-pycharm-diff"]
+markers = [
+    "capstan(app): Allows you to configure capstan-related settings.",
+]

capstan-1.0.0/src/capstan/cli.py

@@ -0,0 +1,34 @@
+
+from cyclopts import App
+
+from capstan.model import ResponseConfig, ServerConfig
+from capstan.tui import TUIApp
+
+app = App(name="capstan", help="A webhook inspector for local development.")
+app.register_install_completion_command()
+
+
+@app.default
+def run(
+    *,
+    host: str = ServerConfig.host,
+    port: int = ServerConfig.port,
+    status: int = ResponseConfig.status,
+):
+    """
+    :param port: The port for the endpoint
+    :param host: The listen address for the endpoint
+    :param status: The response status code for the webhook
+    """
+    server_config = ServerConfig(
+        host=host,
+        port=port,
+        response=ResponseConfig(status=status),
+    )
+
+    tui_app = TUIApp(server_config=server_config)
+    tui_app.run()
+
+
+if __name__ == "__main__":
+    app()

capstan-1.0.0/src/capstan/model.py

@@ -0,0 +1,46 @@
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Coroutine, Mapping
+
+from aiohttp import HttpVersion
+from multidict import MultiMapping, MultiDict
+
+
+@dataclass
+class RequestData(object):
+    timestamp: datetime
+    method: str
+    path: str
+    headers: MultiMapping[str]
+    body: bytes
+    query_params: MultiMapping[str]
+    host: str
+    http_version: HttpVersion
+    cookies: Mapping[str, str]
+
+    @property
+    def content_type(self) -> str:
+        return self.headers.get("Content-Type", "").split(";")[0].strip().lower()
+
+
+@dataclass
+class ResponseConfig(object):
+    status: int = 201
+    headers: MultiMapping[str] = field(default_factory=lambda: MultiDict({"content-type": "application/json"}))
+    body: bytes = '{"status": "received"}'.encode()
+
+
+@dataclass
+class ServerConfig(object):
+    host: str = "127.0.0.1"
+    port: int = 8080
+    response: ResponseConfig = field(default_factory=lambda: ResponseConfig())
+
+    @property
+    def listen_address(self) -> str:
+        # noinspection HttpUrlsUsage
+        return f"http://{self.host}:{self.port}"
+
+
+RequestCallback = Callable[[RequestData], Coroutine[Any, Any, None]]

capstan-1.0.0/src/capstan/server.py

@@ -0,0 +1,70 @@
+from datetime import datetime
+
+from aiohttp import web
+
+from capstan.model import RequestCallback, RequestData, ServerConfig
+
+
+class WebhookServer:
+    def __init__(self, config: ServerConfig, callback: RequestCallback):
+        self.config = config
+        self.callback = callback
+        self.runner = None
+
+    async def handle_request(self, request: web.Request) -> web.Response:
+        request_data = RequestData(
+            timestamp=datetime.now(),
+            method=request.method,
+            path=request.url.path,
+            headers=request.headers,
+            body=await request.read(),
+            query_params=request.query,
+            host=request.host,
+            http_version=request.version,
+            cookies=request.cookies,
+        )
+
+        await self.callback(request_data)
+
+        return web.Response(
+            status=self.config.response.status,
+            body=self.config.response.body,
+            headers=self.config.response.headers,
+        )
+
+    async def start(self):
+        """Starts the aiohttp server within the provided event loop."""
+        app = web.Application()
+        app.router.add_route("*", "/{tail:.*}", self.handle_request)
+
+        self.runner = web.AppRunner(app)
+        await self.runner.setup()
+        site = web.TCPSite(self.runner, self.config.host, self.config.port)
+        await site.start()
+
+    async def stop(self):
+        """Stops the server and cleans up resources."""
+        if self.runner:
+            await self.runner.cleanup()
+
+
+async def _main(): # pragma: no cover
+    async def print_result(request: RequestData):
+        print(request)
+
+    config = ServerConfig(host="0.0.0.0", port=8085)
+
+    server = WebhookServer(config=config, callback=print_result)
+    await server.start()
+    print(f"Started web server at {config.listen_address}.")
+
+    try:
+        await asyncio.Event().wait()
+    except asyncio.CancelledError:
+        await server.stop()
+
+
+if __name__ == "__main__": # pragma: no cover
+    import asyncio
+
+    asyncio.run(_main())

capstan-1.0.0/src/capstan/tui.py

@@ -0,0 +1,117 @@
+from datetime import datetime
+
+from aiohttp import HttpVersion11
+from multidict import MultiDict
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, ScrollableContainer
+from textual.reactive import reactive
+from textual.widgets import Footer, Header
+
+from capstan.model import RequestData, ServerConfig
+from capstan.server import WebhookServer
+from capstan.widgets.request_details import RequestDetails
+from capstan.widgets.sidebar import Sidebar
+from capstan.widgets.status_bar import StatusBar
+
+
+class TUIApp(App):
+    TITLE = "Capstan"
+    SUB_TITLE = "The webhook inspector"
+
+    BINDINGS = [
+        Binding("r", "reset_list", "Reset list"),
+        Binding("c", "copy_body", "Copy body"),
+        Binding("a", "copy_listen_address", "Copy address"),
+        Binding("f", "follow_off", "Auto follow (on)"),
+        Binding("f", "follow_on", "Auto follow (off)"),
+        Binding("q", "quit", "Quit"),
+        Binding("t", "test_request", "Create a test request", show=False),
+    ]
+
+    CSS_PATH = "tui.tcss"
+
+    selected_request: reactive[RequestData | None] = reactive(None)
+    auto_follow: reactive[bool] = reactive(True)
+
+    def __init__(self, server_config: ServerConfig):
+        super().__init__()
+        self.server_config = server_config
+        self.server = WebhookServer(config=server_config, callback=self.add_request)
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal():
+            yield Sidebar().data_bind(TUIApp.auto_follow)
+            with ScrollableContainer():
+                yield RequestDetails().data_bind(request=TUIApp.selected_request)
+        yield StatusBar(self.server_config.listen_address)
+        yield Footer()
+
+    async def on_mount(self) -> None:
+        """Starts the webhook server when the application is mounted."""
+        await self.server.start()
+
+    async def on_unmount(self) -> None:
+        """Gracefully shuts down the server when the application is closed."""
+        await self.server.stop()
+
+    async def action_test_request(self): # pragma: no cover
+        request = RequestData(
+            timestamp=datetime.now(),
+            method="POST",
+            path="/",
+            headers=MultiDict(),
+            body="".encode(),
+            query_params=MultiDict(),
+            host="127.0.0.1",
+            http_version=HttpVersion11,
+            cookies=dict(),
+        )
+        await self.add_request(request)
+
+    def action_reset_list(self):
+        self.query_one(Sidebar).clear()
+        self.selected_request = None
+        self.refresh_bindings()
+
+    def action_copy_body(self):
+        if not self.selected_request or not self.selected_request.body:
+            return
+        try:
+            self.copy_to_clipboard(self.selected_request.body.decode("utf-8"))
+        except UnicodeDecodeError:
+            self.notify("Can't copy body content", title="Copy to clipboard failed!")
+
+    def action_copy_listen_address(self):
+        self.copy_to_clipboard(self.server_config.listen_address)
+
+    async def add_request(self, request: RequestData):
+        await self.query_one(Sidebar).add_request(request)
+
+    def on_sidebar_request_selected(self, event: Sidebar.RequestSelected) -> None:
+        self.selected_request = event.request
+        self.refresh_bindings()
+
+    def action_follow_on(self):
+        self.auto_follow = True
+        self.refresh_bindings()
+
+    def action_follow_off(self):
+        self.auto_follow = False
+        self.refresh_bindings()
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if action == "follow_on" and self.auto_follow:
+            return False
+        if action == "follow_off" and not self.auto_follow:
+            return False
+        if action == "copy_body" and (not self.selected_request or not self.selected_request.body):
+            return False
+        else:
+            return True
+
+
+if __name__ == "__main__": # pragma: no cover
+    app = TUIApp(server_config=ServerConfig())
+    app.run()

capstan-1.0.0/src/capstan/tui.tcss

@@ -0,0 +1,17 @@
+Sidebar {
+    width: 30%;
+    height: 100%;
+    border-right: solid $accent;
+}
+
+RequestDetails {
+    padding: 1;
+}
+
+StatusBar {
+    background: $accent;
+    color: $text;
+    height: 1;
+    width: 100%;
+    content-align: center middle;
+}

capstan-1.0.0/src/capstan/util.py

@@ -0,0 +1,17 @@
+def get_syntax_lexer(content_type: str) -> str | None:
+    """
+    Get a pygmentize lexer based on a Content-Type header
+    """
+    if "json" in content_type:
+        return "json"
+    if "xml" in content_type:
+        return "xml"
+    if "text" in content_type:
+        return "text"
+    if "form-urlencoded" in content_type:
+        return "urlencoded"
+    if "multipart/" in content_type:
+        return "mime"
+    if "application/octet-stream" in content_type:
+        return None
+    return "text"

capstan-1.0.0/src/capstan/widgets/request_body.py

@@ -0,0 +1,56 @@
+from rich.markup import escape
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widgets import Static
+
+from capstan.model import RequestData
+from capstan.util import get_syntax_lexer
+
+
+class RequestBody(Static):
+    BINARY_SIZE_LIMIT = 5 * 1024  # 5KB limit for performance
+    BINARY_ROW_SIZE = 16
+
+    request: reactive[RequestData] = reactive(None, recompose=True)
+    show_line_numbers: reactive[bool] = reactive(True, recompose=True)
+
+    def _hexdump(self, data: bytes) -> Table:
+        """Generates a polished hexdump of the given bytes using a Rich Table."""
+        table = Table(show_header=True, header_style="bold magenta", box=None, padding=(0, 1))
+        table.add_column("Offset", style="dim", justify="right")
+        table.add_column("Hex", style="green")
+        table.add_column("ASCII", style="cyan")
+
+        display_data = data[:self.BINARY_SIZE_LIMIT]
+
+        for i in range(0, len(display_data), self.BINARY_ROW_SIZE):
+            chunk = display_data[i : i + self.BINARY_ROW_SIZE]
+            hex_part = " ".join(f"{b:02x}" for b in chunk)
+            ascii_part = "".join(chr(b) if 32 <= b <= 126 else "." for b in chunk)
+            table.add_row(f"{i:08x}", hex_part, escape(ascii_part))
+
+        if len(data) > self.BINARY_SIZE_LIMIT:
+            table.add_row("...", f"({len(data) - self.BINARY_SIZE_LIMIT} more bytes truncated)", "...")
+
+        return table
+
+    def compose(self) -> ComposeResult:
+        if not self.request or not self.request.body:
+            return
+
+        content_type = self.request.content_type
+        lexer = get_syntax_lexer(content_type)
+        body = self.request.body
+
+        if lexer:
+            try:
+                decoded_body = body.decode("utf-8")
+                syntax = Syntax(decoded_body, lexer, word_wrap=True, line_numbers=self.show_line_numbers)
+                yield Static(Panel(syntax, title=f"Body ({content_type or 'text: unknown'})"))
+            except UnicodeDecodeError:
+                yield Static(Panel(self._hexdump(body), title="Body (binary: unknown)"))
+        else:
+            yield Static(Panel(self._hexdump(body), title=f"Body ({content_type or 'binary: unknown'})"))

capstan-1.0.0/src/capstan/widgets/request_details.py

@@ -0,0 +1,63 @@
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Static
+
+from capstan.model import RequestData
+from capstan.widgets.request_body import RequestBody
+
+
+class RequestDetails(Static):
+    request: reactive[RequestData] = reactive(None, recompose=True)
+
+    def compose(self) -> ComposeResult:
+        if not self.request:
+            return
+
+        yield self.overview_panel()
+        if self.request.query_params:
+            yield self.query_panel()
+        if self.request.headers:
+            yield self.header_panel()
+        if self.request.cookies:
+            yield self.cookie_panel()
+        if self.request.body:
+            yield RequestBody().data_bind(RequestDetails.request)
+
+    def overview_panel(self) -> Widget:
+        timestamp = self.request.timestamp.strftime("%Y-%m-%d %H:%M:%S.%f")
+        rows = [
+            ("Method", self.request.method),
+            ("Path", self.request.path),
+            ("Host", self.request.host),
+            ("Timestamp", timestamp),
+        ]
+
+        table = self._create_table("Key", "Value", rows, show_header=False)
+        return Static(Panel(table, title="Overview"))
+
+    def query_panel(self) -> Widget:
+        table = self._create_table("Query", "Value", self.request.query_params.items())
+        return Static(Panel(table, title="Query params"))
+
+    def cookie_panel(self) -> Widget:
+        table = self._create_table("Parameter", "Value", self.request.cookies.items())
+        return Static(Panel(table, title="Cookies"))
+
+    def header_panel(self) -> Widget:
+        table = self._create_table("Header", "Value", self.request.headers.items())
+        return Static(Panel(table, title="Headers"))
+
+    @staticmethod
+    def _create_table(header_1: str, header_2: str, rows: list[tuple[str, str]], show_header: bool = True) -> Table:
+        table = Table(show_header=show_header, box=box.SIMPLE, expand=True)
+        table.add_column(header_1, style="cyan", overflow="fold", ratio=1)
+        table.add_column(header_2, overflow="fold", ratio=3)
+
+        for key, value in rows:
+            table.add_row(key, str(value))
+
+        return table

capstan-1.0.0/src/capstan/widgets/request_item.py

@@ -0,0 +1,19 @@
+from textual.app import ComposeResult
+from textual.widgets import Label, ListItem
+
+from capstan.model import RequestData
+
+
+class RequestItem(ListItem):
+    def __init__(self, request: RequestData):
+        super().__init__()
+        self.request = request
+
+    def compose(self) -> ComposeResult:
+        method = self.request.method
+        path = self.request.path
+        timestamp = self.request.timestamp
+        time_display = timestamp.strftime("%H:%M:%S")
+
+        yield Label(f"[bold cyan]{method}[/] {path}")
+        yield Label(time_display, classes="timestamp")

capstan-1.0.0/src/capstan/widgets/sidebar.py

@@ -0,0 +1,32 @@
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import ListView
+
+from capstan.model import RequestData
+from capstan.widgets.request_item import RequestItem
+
+
+class Sidebar(ListView):
+    auto_follow: reactive[bool] = reactive(True)
+
+    async def add_request(self, request: RequestData):
+        old_index = self.index
+        self.index = None
+
+        new_item = RequestItem(request)
+        await self.insert(0, [new_item])
+
+        if self.auto_follow or old_index is None:
+            self.index = 0
+        else:
+            self.index = old_index + 1
+
+    def on_list_view_highlighted(self, event: ListView.Highlighted) -> None:
+        if isinstance(event.item, RequestItem):
+            self.post_message(self.RequestSelected(event.item))
+
+    class RequestSelected(Message):
+        def __init__(self, item: RequestItem) -> None:
+            super().__init__()
+            self.request: RequestData = item.request if item else None
+            self.item: RequestItem | None = item

capstan-1.0.0/src/capstan/widgets/status_bar.py

@@ -0,0 +1,18 @@
+from textual.widgets import Label
+
+
+class StatusBar(Label):
+    """A clickable status bar that copies the listen address to clipboard."""
+
+    def __init__(self, listen_address: str):
+        super().__init__()
+        self.listen_address = listen_address
+        self.content = self.original_message = f"Listening on {self.listen_address} (click to copy)"
+
+    def on_click(self) -> None:
+        self.app.copy_to_clipboard(self.listen_address)
+        self.content = f"Copied {self.listen_address} to clipboard!"
+        self.set_timer(3.0, self.reset_message)
+
+    def reset_message(self) -> None:
+        self.content = self.original_message