smello-server 0.1.1__tar.gz

smello_server-0.1.1/.bumpversion.toml

@@ -0,0 +1,16 @@
+[tool.bumpversion]
+current_version = "0.1.1"
+commit = true
+tag = true
+tag_name = "smello-server/v{new_version}"
+tag_message = "Release smello-server v{new_version}"
+message = "Bump smello-server version: {current_version} → {new_version}"
+
+[[tool.bumpversion.files]]
+filename = "server/pyproject.toml"
+key_path = "project.version"
+
+[[tool.bumpversion.files]]
+filename = "server/src/smello_server/__init__.py"
+search = '__version__ = "{current_version}"'
+replace = '__version__ = "{new_version}"'

smello_server-0.1.1/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+*.so
+.venv/
+venv/
+env/
+.env
+*.db
+*.sqlite3
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+*.log
+.DS_Store
+Thumbs.db

smello_server-0.1.1/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: smello-server
+Version: 0.1.1
+Summary: A local web dashboard for inspecting outgoing HTTP requests from your code
+Project-URL: Homepage, https://github.com/smelloscope/smello
+Project-URL: Repository, https://github.com/smelloscope/smello
+Project-URL: Issues, https://github.com/smelloscope/smello/issues
+Author-email: Roman Imankulov <roman.imankulov@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: System :: Networking :: Monitoring
+Requires-Python: >=3.14
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: tortoise-orm>=0.22.0
+Requires-Dist: uvicorn[standard]>=0.34.0
+Description-Content-Type: text/markdown
+
+# Smello Server
+
+A local web dashboard for inspecting outgoing HTTP requests captured by the [smello](https://pypi.org/project/smello/) client SDK.
+
+## Setup
+
+```bash
+pip install smello-server
+smello-server run
+```
+
+The dashboard opens at `http://localhost:5110`.
+
+Or with Docker:
+
+```bash
+docker run -p 5110:5110 ghcr.io/smelloscope/smello
+```
+
+Then add the client SDK to your Python code:
+
+```bash
+pip install smello
+```
+
+```python
+import smello
+smello.init()
+
+# All outgoing requests via requests/httpx are now captured
+```
+
+## API
+
+Smello Server provides a JSON API for exploring captured requests from the command line.
+
+```bash
+# List all captured requests
+curl -s http://localhost:5110/api/requests | python -m json.tool
+
+# Filter by method, host, status, or URL substring
+curl -s 'http://localhost:5110/api/requests?method=POST&host=api.stripe.com'
+
+# Get full request/response details
+curl -s http://localhost:5110/api/requests/{id} | python -m json.tool
+
+# Clear all requests
+curl -X DELETE http://localhost:5110/api/requests
+```
+
+## CLI Options
+
+```bash
+smello-server run --host 0.0.0.0 --port 5110 --db-path /tmp/smello.db
+```
+
+## Requires
+
+- Python >= 3.14
+
+## Links
+
+- [Documentation & Source](https://github.com/smelloscope/smello)
+- [smello client SDK on PyPI](https://pypi.org/project/smello/)

smello_server-0.1.1/README.md

@@ -0,0 +1,64 @@
+# Smello Server
+
+A local web dashboard for inspecting outgoing HTTP requests captured by the [smello](https://pypi.org/project/smello/) client SDK.
+
+## Setup
+
+```bash
+pip install smello-server
+smello-server run
+```
+
+The dashboard opens at `http://localhost:5110`.
+
+Or with Docker:
+
+```bash
+docker run -p 5110:5110 ghcr.io/smelloscope/smello
+```
+
+Then add the client SDK to your Python code:
+
+```bash
+pip install smello
+```
+
+```python
+import smello
+smello.init()
+
+# All outgoing requests via requests/httpx are now captured
+```
+
+## API
+
+Smello Server provides a JSON API for exploring captured requests from the command line.
+
+```bash
+# List all captured requests
+curl -s http://localhost:5110/api/requests | python -m json.tool
+
+# Filter by method, host, status, or URL substring
+curl -s 'http://localhost:5110/api/requests?method=POST&host=api.stripe.com'
+
+# Get full request/response details
+curl -s http://localhost:5110/api/requests/{id} | python -m json.tool
+
+# Clear all requests
+curl -X DELETE http://localhost:5110/api/requests
+```
+
+## CLI Options
+
+```bash
+smello-server run --host 0.0.0.0 --port 5110 --db-path /tmp/smello.db
+```
+
+## Requires
+
+- Python >= 3.14
+
+## Links
+
+- [Documentation & Source](https://github.com/smelloscope/smello)
+- [smello client SDK on PyPI](https://pypi.org/project/smello/)

smello_server-0.1.1/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "smello-server"
+version = "0.1.1"
+description = "A local web dashboard for inspecting outgoing HTTP requests from your code"
+license = "MIT"
+requires-python = ">=3.14"
+readme = "README.md"
+authors = [{ name = "Roman Imankulov", email = "roman.imankulov@gmail.com" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Framework :: FastAPI",
+    "Topic :: Software Development :: Testing",
+    "Topic :: System :: Networking :: Monitoring",
+]
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.34.0",
+    "jinja2>=3.1.0",
+    "tortoise-orm>=0.22.0",
+    "aiosqlite>=0.20.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/smelloscope/smello"
+Repository = "https://github.com/smelloscope/smello"
+Issues = "https://github.com/smelloscope/smello/issues"
+
+[project.scripts]
+smello-server = "smello_server.__main__:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/smello_server"]

smello_server-0.1.1/src/smello_server/__init__.py

@@ -0,0 +1,3 @@
+"""Smello Server - HTTP request inspection dashboard."""
+
+__version__ = "0.1.1"

smello_server-0.1.1/src/smello_server/__main__.py

@@ -0,0 +1,50 @@
+"""CLI entry point: `smello-server run` or `python -m smello_server`."""
+
+import argparse
+import os
+
+import uvicorn
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="smello-server", description="Smello HTTP request inspector"
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    run_parser = subparsers.add_parser("run", help="Start the Smello server")
+    run_parser.add_argument(
+        "--host", default="0.0.0.0", help="Host to bind to (default: 0.0.0.0)"
+    )
+    run_parser.add_argument(
+        "--port", type=int, default=5110, help="Port to bind to (default: 5110)"
+    )
+    run_parser.add_argument(
+        "--db-path", default=None, help="Path to SQLite database file"
+    )
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        args.command = "run"
+        args.host = "0.0.0.0"
+        args.port = 5110
+        args.db_path = None
+
+    if args.command == "run":
+        if args.db_path:
+            os.environ["SMELLO_DB_PATH"] = args.db_path
+
+        from smello_server.app import create_app
+
+        app = create_app()
+        uvicorn.run(
+            app,
+            host=args.host,
+            port=args.port,
+            log_level="info",
+        )
+
+
+if __name__ == "__main__":
+    main()

smello_server-0.1.1/src/smello_server/app.py

@@ -0,0 +1,47 @@
+"""FastAPI application setup with Tortoise ORM."""
+
+import os
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from tortoise.contrib.fastapi import register_tortoise
+
+from smello_server.routes.api import router as api_router
+from smello_server.routes.web import router as web_router
+
+PACKAGE_DIR = Path(__file__).parent
+TEMPLATES_DIR = PACKAGE_DIR / "templates"
+STATIC_DIR = PACKAGE_DIR / "static"
+
+templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
+
+
+def _get_db_url() -> str:
+    db_path = os.environ.get("SMELLO_DB_PATH")
+    if db_path:
+        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+        return f"sqlite://{db_path}"
+    default_dir = Path.home() / ".smello"
+    default_dir.mkdir(parents=True, exist_ok=True)
+    return f"sqlite://{default_dir / 'smello.db'}"
+
+
+def create_app(db_url: str | None = None) -> FastAPI:
+    """Create and configure the FastAPI application."""
+    application = FastAPI(title="Smello")
+
+    application.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+    application.include_router(api_router)
+    application.include_router(web_router)
+
+    register_tortoise(
+        application,
+        db_url=db_url or _get_db_url(),
+        modules={"models": ["smello_server.models"]},
+        generate_schemas=True,
+        add_exception_handlers=True,
+    )
+
+    return application

smello_server-0.1.1/src/smello_server/models.py

@@ -0,0 +1,31 @@
+"""Tortoise ORM models for captured HTTP requests."""
+
+from tortoise import fields
+from tortoise.models import Model
+
+
+class CapturedRequest(Model):
+    id = fields.UUIDField(pk=True)
+    timestamp = fields.DatetimeField(auto_now_add=True)
+    duration_ms = fields.IntField()
+
+    # Request
+    method = fields.CharField(max_length=10)
+    url = fields.TextField()
+    request_headers: dict = fields.JSONField()
+    request_body = fields.TextField(null=True)
+    request_body_size = fields.IntField(default=0)
+
+    # Response
+    status_code = fields.IntField()
+    response_headers: dict = fields.JSONField()
+    response_body = fields.TextField(null=True)
+    response_body_size = fields.IntField(default=0)
+
+    # Meta
+    host = fields.CharField(max_length=255, index=True)
+    library = fields.CharField(max_length=50)
+
+    class Meta:
+        table = "captured_requests"
+        ordering = ["-timestamp"]

smello_server-0.1.1/src/smello_server/routes/api.py

@@ -0,0 +1,160 @@
+"""API routes: ingestion endpoint and JSON API."""
+
+import uuid
+from datetime import datetime
+from urllib.parse import urlparse
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from smello_server.models import CapturedRequest
+
+router = APIRouter(prefix="/api")
+
+
+# --- Input models ---
+
+
+class RequestData(BaseModel):
+    method: str
+    url: str
+    headers: dict[str, str]
+    body: str | None = None
+    body_size: int = 0
+
+
+class ResponseData(BaseModel):
+    status_code: int
+    headers: dict[str, str]
+    body: str | None = None
+    body_size: int = 0
+
+
+class MetaData(BaseModel):
+    library: str = "unknown"
+    python_version: str = ""
+    smello_version: str = ""
+
+
+class CapturePayload(BaseModel):
+    id: str | None = None
+    timestamp: str | None = None
+    duration_ms: int = 0
+    request: RequestData
+    response: ResponseData
+    meta: MetaData = MetaData()
+
+
+# --- Output models ---
+
+
+class CaptureResponse(BaseModel):
+    status: str
+
+
+class RequestSummary(BaseModel):
+    id: str
+    timestamp: datetime
+    method: str
+    url: str
+    host: str
+    status_code: int
+    duration_ms: int
+
+
+class RequestDetail(RequestSummary):
+    library: str
+    request_headers: dict[str, str]
+    request_body: str | None
+    request_body_size: int
+    response_headers: dict[str, str]
+    response_body: str | None
+    response_body_size: int
+
+
+# --- Routes ---
+
+
+@router.post("/capture", status_code=201, response_model=CaptureResponse)
+async def capture(payload: CapturePayload) -> CaptureResponse:
+    host = urlparse(payload.request.url).hostname or "unknown"
+
+    await CapturedRequest.create(
+        id=payload.id or uuid.uuid4(),
+        duration_ms=payload.duration_ms,
+        method=payload.request.method.upper(),
+        url=payload.request.url,
+        request_headers=payload.request.headers,
+        request_body=payload.request.body,
+        request_body_size=payload.request.body_size,
+        status_code=payload.response.status_code,
+        response_headers=payload.response.headers,
+        response_body=payload.response.body,
+        response_body_size=payload.response.body_size,
+        host=host,
+        library=payload.meta.library,
+    )
+    return CaptureResponse(status="ok")
+
+
+@router.get("/requests", response_model=list[RequestSummary])
+async def list_requests(
+    host: str | None = Query(None),
+    method: str | None = Query(None),
+    status: int | None = Query(None),
+    search: str | None = Query(None),
+    limit: int = Query(50, le=200),
+) -> list[RequestSummary]:
+    qs = CapturedRequest.all()
+    if host:
+        qs = qs.filter(host=host)
+    if method:
+        qs = qs.filter(method=method.upper())
+    if status:
+        qs = qs.filter(status_code=status)
+    if search:
+        qs = qs.filter(url__icontains=search)
+
+    requests = await qs.limit(limit)
+    return [
+        RequestSummary(
+            id=str(r.id),
+            timestamp=r.timestamp,
+            method=r.method,
+            url=r.url,
+            host=r.host,
+            status_code=r.status_code,
+            duration_ms=r.duration_ms,
+        )
+        for r in requests
+    ]
+
+
+@router.get("/requests/{request_id}", response_model=RequestDetail)
+async def get_request(request_id: str) -> RequestDetail:
+    try:
+        r = await CapturedRequest.get(id=request_id)
+    except Exception:
+        raise HTTPException(status_code=404, detail="Request not found")
+
+    return RequestDetail(
+        id=str(r.id),
+        timestamp=r.timestamp,
+        method=r.method,
+        url=r.url,
+        host=r.host,
+        status_code=r.status_code,
+        duration_ms=r.duration_ms,
+        library=r.library,
+        request_headers=r.request_headers,
+        request_body=r.request_body,
+        request_body_size=r.request_body_size,
+        response_headers=r.response_headers,
+        response_body=r.response_body,
+        response_body_size=r.response_body_size,
+    )
+
+
+@router.delete("/requests", status_code=204)
+async def clear_requests() -> None:
+    await CapturedRequest.all().delete()

smello_server-0.1.1/src/smello_server/routes/web.py

@@ -0,0 +1,82 @@
+"""Web UI routes: request list and detail pages."""
+
+from fastapi import APIRouter, Query, Request
+from fastapi.responses import HTMLResponse
+
+from smello_server.models import CapturedRequest
+
+router = APIRouter(include_in_schema=False)
+
+
+@router.get("/", response_class=HTMLResponse)
+async def request_list(
+    request: Request,
+    host: str | None = Query(None),
+    method: str | None = Query(None),
+    status: int | None = Query(None),
+    search: str | None = Query(None),
+    _partial: str | None = Query(None),
+):
+    from smello_server.app import templates
+
+    qs = CapturedRequest.all()
+    if host:
+        qs = qs.filter(host=host)
+    if method:
+        qs = qs.filter(method=method.upper())
+    if status:
+        qs = qs.filter(status_code=status)
+    if search:
+        qs = qs.filter(url__icontains=search)
+
+    requests_list = await qs.limit(100)
+
+    hosts = await CapturedRequest.all().distinct().values_list("host", flat=True)
+    methods = await CapturedRequest.all().distinct().values_list("method", flat=True)
+
+    context = {
+        "request": request,
+        "requests": requests_list,
+        "hosts": sorted(set(hosts)),
+        "methods": sorted(set(methods)),
+        "filter_host": host or "",
+        "filter_method": method or "",
+        "filter_status": status or "",
+        "filter_search": search or "",
+        "selected_id": "",
+    }
+
+    if _partial == "list":
+        return templates.TemplateResponse("partials/request_list_items.html", context)
+
+    return templates.TemplateResponse("request_list.html", context)
+
+
+@router.get("/requests/{request_id}", response_class=HTMLResponse)
+async def request_detail(request: Request, request_id: str):
+    from smello_server.app import templates
+
+    captured = await CapturedRequest.get(id=request_id)
+
+    return templates.TemplateResponse(
+        "request_detail.html",
+        {
+            "request": request,
+            "captured": captured,
+        },
+    )
+
+
+@router.get("/requests/{request_id}/partial", response_class=HTMLResponse)
+async def request_detail_partial(request: Request, request_id: str):
+    from smello_server.app import templates
+
+    captured = await CapturedRequest.get(id=request_id)
+
+    return templates.TemplateResponse(
+        "partials/request_detail_partial.html",
+        {
+            "request": request,
+            "captured": captured,
+        },
+    )