Fix FastAPI response model for union return type

- Add /api/v1/nodes/prefix/{prefix} for prefix-based node lookup
- Change /api/v1/nodes/{public_key} to exact match only
- /n/{prefix} now simply redirects to /nodes/{prefix}
- /nodes/{key} resolves prefixes via API and redirects to full key

.github/workflows/ci.yml

@@ -18,20 +18,8 @@ jobs:
         with:
           python-version: "3.13"
 
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install black flake8 mypy
-          pip install -e ".[dev]"
-
-      - name: Check formatting with black
-        run: black --check src/ tests/
-
-      - name: Lint with flake8
-        run: flake8 src/ tests/
-
-      - name: Type check with mypy
-        run: mypy src/
+      - name: Run pre-commit
+        uses: pre-commit/action@v3.0.1
 
   test:
     name: Test (Python ${{ matrix.python-version }})

src/meshcore_hub/api/routes/nodes.py

@@ -2,7 +2,7 @@
 
 from typing import Optional
 
-from fastapi import APIRouter, HTTPException, Query
+from fastapi import APIRouter, HTTPException, Path, Query
 from sqlalchemy import func, or_, select
 from sqlalchemy.orm import selectinload
 
@@ -77,14 +77,43 @@ async def list_nodes(
     )
 
 
-@router.get("/{public_key}", response_model=NodeRead)
-async def get_node(
+@router.get("/prefix/{prefix}", response_model=NodeRead)
+async def get_node_by_prefix(
     _: RequireRead,
     session: DbSession,
-    public_key: str,
+    prefix: str = Path(description="Public key prefix to search for"),
 ) -> NodeRead:
-    """Get a single node by public key."""
-    query = select(Node).where(Node.public_key == public_key)
+    """Get a single node by public key prefix.
+
+    Returns the first node (alphabetically by public_key) that matches the prefix.
+    """
+    query = (
+        select(Node)
+        .options(selectinload(Node.tags))
+        .where(Node.public_key.startswith(prefix))
+        .order_by(Node.public_key)
+        .limit(1)
+    )
+    node = session.execute(query).scalar_one_or_none()
+
+    if not node:
+        raise HTTPException(status_code=404, detail="Node not found")
+
+    return NodeRead.model_validate(node)
+
+
+@router.get("/{public_key}", response_model=NodeRead)
+async def get_node(
+    _: RequireRead,
+    session: DbSession,
+    public_key: str = Path(description="Full 64-character public key"),
+) -> NodeRead:
+    """Get a single node by exact public key match."""
+    query = (
+        select(Node)
+        .options(selectinload(Node.tags))
+        .where(Node.public_key == public_key)
+    )
     node = session.execute(query).scalar_one_or_none()
 
     if not node:

src/meshcore_hub/common/hash_utils.py

@@ -49,7 +49,7 @@ def compute_advertisement_hash(
     adv_type: Optional[str] = None,
     flags: Optional[int] = None,
     received_at: Optional[datetime] = None,
-    bucket_seconds: int = 30,
+    bucket_seconds: int = 120,
 ) -> str:
     """Compute a deterministic hash for an advertisement.
 
@@ -104,7 +104,7 @@ def compute_telemetry_hash(
     node_public_key: str,
     parsed_data: Optional[dict] = None,
     received_at: Optional[datetime] = None,
-    bucket_seconds: int = 30,
+    bucket_seconds: int = 120,
 ) -> str:
     """Compute a deterministic hash for a telemetry record.
 

src/meshcore_hub/web/app.py

@@ -7,8 +7,10 @@ from typing import AsyncGenerator
 
 import httpx
 from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
+from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from meshcore_hub import __version__
 from meshcore_hub.common.schemas import RadioConfig
@@ -150,6 +152,24 @@ def create_app(
         except Exception as e:
             return {"status": "not_ready", "api": str(e)}
 
+    @app.exception_handler(StarletteHTTPException)
+    async def http_exception_handler(
+        request: Request, exc: StarletteHTTPException
+    ) -> HTMLResponse:
+        """Handle HTTP exceptions with custom error pages."""
+        if exc.status_code == 404:
+            context = get_network_context(request)
+            context["request"] = request
+            context["detail"] = exc.detail if exc.detail != "Not Found" else None
+            return templates.TemplateResponse(
+                "errors/404.html", context, status_code=404
+            )
+        # For other errors, return a simple response
+        return HTMLResponse(
+            content=f"<h1>{exc.status_code}</h1><p>{exc.detail}</p>",
+            status_code=exc.status_code,
+        )
+
     return app
 
 

src/meshcore_hub/web/routes/messages.py

@@ -15,7 +15,6 @@ router = APIRouter()
 async def messages_list(
     request: Request,
     message_type: str | None = Query(None, description="Filter by message type"),
-    channel_idx: str | None = Query(None, description="Filter by channel"),
     search: str | None = Query(None, description="Search in message text"),
     page: int = Query(1, ge=1, description="Page number"),
     limit: int = Query(50, ge=1, le=100, description="Items per page"),
@@ -28,20 +27,10 @@ async def messages_list(
     # Calculate offset
     offset = (page - 1) * limit
 
-    # Parse channel_idx, treating empty string as None
-    channel_idx_int: int | None = None
-    if channel_idx and channel_idx.strip():
-        try:
-            channel_idx_int = int(channel_idx)
-        except ValueError:
-            logger.warning(f"Invalid channel_idx value: {channel_idx}")
-
     # Build query params
     params: dict[str, int | str] = {"limit": limit, "offset": offset}
     if message_type:
         params["message_type"] = message_type
-    if channel_idx_int is not None:
-        params["channel_idx"] = channel_idx_int
 
     # Fetch messages from API
     messages = []
@@ -70,7 +59,6 @@ async def messages_list(
             "limit": limit,
             "total_pages": total_pages,
             "message_type": message_type or "",
-            "channel_idx": channel_idx_int,
             "search": search or "",
         }
     )

src/meshcore_hub/web/routes/nodes.py

@@ -2,8 +2,8 @@
 
 import logging
 
-from fastapi import APIRouter, Query, Request
-from fastapi.responses import HTMLResponse
+from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
 
 from meshcore_hub.web.app import get_network_context, get_templates
 
@@ -81,25 +81,45 @@ async def nodes_list(
     return templates.TemplateResponse("nodes.html", context)
 
 
-@router.get("/nodes/{public_key}", response_class=HTMLResponse)
-async def node_detail(request: Request, public_key: str) -> HTMLResponse:
-    """Render the node detail page."""
+@router.get("/n/{prefix}")
+async def node_short_link(prefix: str) -> RedirectResponse:
+    """Redirect short link to nodes page."""
+    return RedirectResponse(url=f"/nodes/{prefix}", status_code=302)
+
+
+@router.get("/nodes/{public_key}", response_model=None)
+async def node_detail(
+    request: Request, public_key: str
+) -> HTMLResponse | RedirectResponse:
+    """Render the node detail page.
+
+    If the key is not a full 64-character public key, uses the prefix API
+    to resolve it and redirects to the canonical URL.
+    """
+    # If not a full public key, resolve via prefix API and redirect
+    if len(public_key) != 64:
+        response = await request.app.state.http_client.get(
+            f"/api/v1/nodes/prefix/{public_key}"
+        )
+        if response.status_code == 200:
+            node = response.json()
+            return RedirectResponse(url=f"/nodes/{node['public_key']}", status_code=302)
+        raise HTTPException(status_code=404, detail="Node not found")
+
     templates = get_templates(request)
     context = get_network_context(request)
     context["request"] = request
 
-    node = None
     advertisements = []
     telemetry = []
 
-    try:
-        # Fetch node details
-        response = await request.app.state.http_client.get(
-            f"/api/v1/nodes/{public_key}"
-        )
-        if response.status_code == 200:
-            node = response.json()
+    # Fetch node details (exact match)
+    response = await request.app.state.http_client.get(f"/api/v1/nodes/{public_key}")
+    if response.status_code != 200:
+        raise HTTPException(status_code=404, detail="Node not found")
+    node = response.json()
 
+    try:
         # Fetch recent advertisements for this node
         response = await request.app.state.http_client.get(
             "/api/v1/advertisements", params={"public_key": public_key, "limit": 10}

src/meshcore_hub/web/templates/errors/404.html

@@ -0,0 +1,35 @@
+{% extends "base.html" %}
+
+{% block title %}Page Not Found - {{ network_name }}{% endblock %}
+
+{% block content %}
+<div class="hero min-h-[60vh]">
+    <div class="hero-content text-center">
+        <div class="max-w-md">
+            <div class="text-9xl font-bold text-primary opacity-20">404</div>
+            <h1 class="text-4xl font-bold -mt-8">Page Not Found</h1>
+            <p class="py-6 text-base-content/70">
+                {% if detail %}
+                {{ detail }}
+                {% else %}
+                The page you're looking for doesn't exist or has been moved.
+                {% endif %}
+            </p>
+            <div class="flex gap-4 justify-center">
+                <a href="/" class="btn btn-primary">
+                    <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-2" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6" />
+                    </svg>
+                    Go Home
+                </a>
+                <a href="/nodes" class="btn btn-outline">
+                    <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-2" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10" />
+                    </svg>
+                    Browse Nodes
+                </a>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %}

src/meshcore_hub/web/templates/messages.html

@@ -28,21 +28,10 @@
                 </label>
                 <select name="message_type" class="select select-bordered select-sm">
                     <option value="">All Types</option>
-                    <option value="direct" {% if message_type == 'direct' %}selected{% endif %}>Direct</option>
+                    <option value="contact" {% if message_type == 'contact' %}selected{% endif %}>Direct</option>
                     <option value="channel" {% if message_type == 'channel' %}selected{% endif %}>Channel</option>
                 </select>
             </div>
-            <div class="form-control">
-                <label class="label py-1">
-                    <span class="label-text">Channel</span>
-                </label>
-                <select name="channel_idx" class="select select-bordered select-sm">
-                    <option value="">All Channels</option>
-                    {% for i in range(8) %}
-                    <option value="{{ i }}" {% if channel_idx == i %}selected{% endif %}>Channel {{ i }}</option>
-                    {% endfor %}
-                </select>
-            </div>
             <div class="flex gap-2 w-full sm:w-auto">
                 <button type="submit" class="btn btn-primary btn-sm">Filter</button>
                 <a href="/messages" class="btn btn-ghost btn-sm">Clear</a>
@@ -64,7 +53,7 @@
                     <div class="min-w-0">
                         <div class="font-medium text-sm truncate">
                             {% if msg.message_type == 'channel' %}
-                            <span class="font-mono">CH{{ msg.channel_idx }}</span>
+                            <span class="opacity-60">Public</span>
                             {% else %}
                                 {% if msg.sender_tag_name or msg.sender_name %}
                                 {{ msg.sender_tag_name or msg.sender_name }}
@@ -105,7 +94,7 @@
             <tr>
                 <th>Type</th>
                 <th>Time</th>
-                <th>From/Channel</th>
+                <th>From</th>
                 <th>Message</th>
                 <th>Receivers</th>
             </tr>
@@ -121,7 +110,7 @@
                 </td>
                 <td class="text-sm whitespace-nowrap">
                     {% if msg.message_type == 'channel' %}
-                    <span class="font-mono">CH{{ msg.channel_idx }}</span>
+                    <span class="opacity-60">Public</span>
                     {% else %}
                         {% if msg.sender_tag_name or msg.sender_name %}
                         <span class="font-medium">{{ msg.sender_tag_name or msg.sender_name }}</span>
@@ -154,5 +143,5 @@
     </table>
 </div>
 
-{{ pagination(page, total_pages, {"message_type": message_type, "channel_idx": channel_idx, "limit": limit}) }}
+{{ pagination(page, total_pages, {"message_type": message_type, "limit": limit}) }}
 {% endblock %}

tests/test_api/test_nodes.py

@@ -146,6 +146,54 @@ class TestGetNode:
         response = client_no_auth.get("/api/v1/nodes/nonexistent123")
         assert response.status_code == 404
 
+    def test_get_node_by_prefix(self, client_no_auth, sample_node):
+        """Test getting a node by public key prefix."""
+        prefix = sample_node.public_key[:8]  # First 8 chars
+        response = client_no_auth.get(f"/api/v1/nodes/prefix/{prefix}")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["public_key"] == sample_node.public_key
+
+    def test_get_node_by_single_char_prefix(self, client_no_auth, sample_node):
+        """Test getting a node by single character prefix."""
+        prefix = sample_node.public_key[0]
+        response = client_no_auth.get(f"/api/v1/nodes/prefix/{prefix}")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["public_key"] == sample_node.public_key
+
+    def test_get_node_prefix_returns_first_alphabetically(
+        self, client_no_auth, api_db_session
+    ):
+        """Test that prefix match returns first node alphabetically."""
+        from datetime import datetime, timezone
+
+        from meshcore_hub.common.models import Node
+
+        # Create two nodes with same prefix but different suffixes
+        # abc... should come before abd...
+        node_a = Node(
+            public_key="abc0000000000000000000000000000000000000000000000000000000000000",
+            name="Node A",
+            adv_type="REPEATER",
+            first_seen=datetime.now(timezone.utc),
+        )
+        node_b = Node(
+            public_key="abc1111111111111111111111111111111111111111111111111111111111111",
+            name="Node B",
+            adv_type="REPEATER",
+            first_seen=datetime.now(timezone.utc),
+        )
+        api_db_session.add(node_a)
+        api_db_session.add(node_b)
+        api_db_session.commit()
+
+        # Request with prefix should return first alphabetically
+        response = client_no_auth.get("/api/v1/nodes/prefix/abc")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["public_key"] == node_a.public_key
+
 
 class TestNodeTags:
     """Tests for node tag endpoints."""

tests/test_web/conftest.py

@@ -40,7 +40,7 @@ class MockHttpClient:
                 "items": [
                     {
                         "id": "node-1",
-                        "public_key": "abc123def456abc123def456abc123de",
+                        "public_key": "abc123def456abc123def456abc123def456abc123def456abc123def456abc1",
                         "name": "Node One",
                         "adv_type": "REPEATER",
                         "last_seen": "2024-01-01T12:00:00Z",
@@ -48,7 +48,7 @@ class MockHttpClient:
                     },
                     {
                         "id": "node-2",
-                        "public_key": "def456abc123def456abc123def456ab",
+                        "public_key": "def456abc123def456abc123def456abc123def456abc123def456abc123def4",
                         "name": "Node Two",
                         "adv_type": "CLIENT",
                         "last_seen": "2024-01-01T11:00:00Z",
@@ -62,12 +62,14 @@ class MockHttpClient:
             },
         }
 
-        # Default single node response
-        self._responses["GET:/api/v1/nodes/abc123def456abc123def456abc123de"] = {
+        # Default single node response (exact match)
+        self._responses[
+            "GET:/api/v1/nodes/abc123def456abc123def456abc123def456abc123def456abc123def456abc1"
+        ] = {
             "status_code": 200,
             "json": {
                 "id": "node-1",
-                "public_key": "abc123def456abc123def456abc123de",
+                "public_key": "abc123def456abc123def456abc123def456abc123def456abc123def456abc1",
                 "name": "Node One",
                 "adv_type": "REPEATER",
                 "last_seen": "2024-01-01T12:00:00Z",
@@ -110,7 +112,7 @@ class MockHttpClient:
                 "items": [
                     {
                         "id": "adv-1",
-                        "public_key": "abc123def456abc123def456abc123de",
+                        "public_key": "abc123def456abc123def456abc123def456abc123def456abc123def456abc1",
                         "name": "Node One",
                         "adv_type": "REPEATER",
                         "received_at": "2024-01-01T12:00:00Z",
@@ -127,7 +129,7 @@ class MockHttpClient:
                 "items": [
                     {
                         "id": "tel-1",
-                        "node_public_key": "abc123def456abc123def456abc123de",
+                        "node_public_key": "abc123def456abc123def456abc123def456abc123def456abc123def456abc1",
                         "parsed_data": {"battery_level": 85.5},
                         "received_at": "2024-01-01T12:00:00Z",
                     },

tests/test_web/test_nodes.py

@@ -73,21 +73,27 @@ class TestNodeDetailPage:
         self, client: TestClient, mock_http_client: MockHttpClient
     ) -> None:
         """Test that node detail page returns 200 status code."""
-        response = client.get("/nodes/abc123def456abc123def456abc123de")
+        response = client.get(
+            "/nodes/abc123def456abc123def456abc123def456abc123def456abc123def456abc1"
+        )
         assert response.status_code == 200
 
     def test_node_detail_returns_html(
         self, client: TestClient, mock_http_client: MockHttpClient
     ) -> None:
         """Test that node detail page returns HTML content."""
-        response = client.get("/nodes/abc123def456abc123def456abc123de")
+        response = client.get(
+            "/nodes/abc123def456abc123def456abc123def456abc123def456abc123def456abc1"
+        )
         assert "text/html" in response.headers["content-type"]
 
     def test_node_detail_displays_node_info(
         self, client: TestClient, mock_http_client: MockHttpClient
     ) -> None:
         """Test that node detail page displays node information."""
-        response = client.get("/nodes/abc123def456abc123def456abc123de")
+        response = client.get(
+            "/nodes/abc123def456abc123def456abc123def456abc123def456abc123def456abc1"
+        )
         assert response.status_code == 200
         # Should display node details
         assert "Node One" in response.text
@@ -98,8 +104,13 @@ class TestNodeDetailPage:
         self, client: TestClient, mock_http_client: MockHttpClient
     ) -> None:
         """Test that node detail page displays the full public key."""
-        response = client.get("/nodes/abc123def456abc123def456abc123de")
-        assert "abc123def456abc123def456abc123de" in response.text
+        response = client.get(
+            "/nodes/abc123def456abc123def456abc123def456abc123def456abc123def456abc1"
+        )
+        assert (
+            "abc123def456abc123def456abc123def456abc123def456abc123def456abc1"
+            in response.text
+        )
 
 
 class TestNodesPageAPIErrors:
@@ -123,7 +134,7 @@ class TestNodesPageAPIErrors:
     def test_node_detail_handles_not_found(
         self, web_app: Any, mock_http_client: MockHttpClient
     ) -> None:
-        """Test that node detail page handles 404 from API."""
+        """Test that node detail page returns 404 when node not found."""
         mock_http_client.set_response(
             "GET",
             "/api/v1/nodes/nonexistent",
@@ -132,8 +143,9 @@ class TestNodesPageAPIErrors:
         )
         web_app.state.http_client = mock_http_client
 
-        client = TestClient(web_app, raise_server_exceptions=True)
+        client = TestClient(web_app, raise_server_exceptions=False)
         response = client.get("/nodes/nonexistent")
 
-        # Should still return 200 (page renders but shows no node)
-        assert response.status_code == 200
+        # Should return 404 with custom error page
+        assert response.status_code == 404
+        assert "Page Not Found" in response.text