vibetuner 2.26.9__py3-none-any.whl → 2.44.1__py3-none-any.whl

vibetuner/cli/__init__.py

@@ -4,14 +4,13 @@ import importlib.metadata
 import inspect
 from functools import partial, wraps
 from importlib import import_module
-from pathlib import Path
-from typing import Annotated
 
 import asyncer
 import typer
 from rich.console import Console
 from rich.table import Table
 
+from vibetuner.cli.db import db_app
 from vibetuner.cli.run import run_app
 from vibetuner.cli.scaffold import scaffold_app
 from vibetuner.logging import LogLevel, logger, setup_logging
@@ -111,21 +110,7 @@ def version(
     console.print(table)
 
 
-@app.command()
-def core_template_symlink(
-    target: Annotated[
-        Path,
-        typer.Argument(
-            help="Path where the 'core' symlink should be created or updated",
-        ),
-    ],
-) -> None:
-    """Create or update a 'core' symlink to the package templates directory."""
-    from vibetuner.paths import create_core_templates_symlink
-
-    create_core_templates_symlink(target)
-
-
+app.add_typer(db_app, name="db")
 app.add_typer(run_app, name="run")
 app.add_typer(scaffold_app, name="scaffold")
 

vibetuner/cli/db.py

@@ -0,0 +1,40 @@
+# ABOUTME: Database management CLI commands for SQLModel.
+# ABOUTME: Provides schema creation and other database utilities.
+
+import asyncer
+import typer
+
+
+db_app = typer.Typer(help="Database management commands", no_args_is_help=True)
+
+
+@db_app.command("create-schema")
+def create_schema_cmd() -> None:
+    """
+    Create database tables from SQLModel metadata.
+
+    This command creates all tables defined in your SQLModel models.
+    It's idempotent - existing tables are not modified.
+
+    Run this during initial setup or after adding new models.
+    """
+    from importlib import import_module
+
+    from vibetuner.logging import logger
+
+    # Import app.models to register SQLModel tables before schema creation
+    try:
+        import_module("app.models")
+    except ModuleNotFoundError:
+        logger.warning("app.models not found. Only core models will be created.")
+    except ImportError as e:
+        logger.warning(f"Failed to import app.models: {e}")
+
+    async def _create() -> None:
+        from vibetuner.sqlmodel import create_schema
+
+        await create_schema()
+
+    typer.echo("Creating database schema...")
+    asyncer.runnify(_create)()
+    typer.echo("Database schema created successfully.")

vibetuner/cli/run.py

@@ -1,11 +1,15 @@
 # ABOUTME: Run commands for starting the application in different modes
 # ABOUTME: Supports dev/prod modes for frontend and worker services
+import hashlib
 import os
-from typing import Annotated
+from pathlib import Path
+from typing import Annotated, Literal
 
 import typer
 from rich.console import Console
 
+from vibetuner.logging import logger
+
 
 console = Console()
 
@@ -13,88 +17,148 @@ run_app = typer.Typer(
     help="Run the application in different modes", no_args_is_help=True
 )
 
+DEFAULT_FRONTEND_PORT = 8000
+DEFAULT_WORKER_PORT = 11111
 
-@run_app.command(name="dev")
-def dev(
-    service: Annotated[
-        str, typer.Argument(help="Service to run: 'frontend' or 'worker'")
-    ] = "frontend",
-    port: int = typer.Option(
-        None, help="Port to run on (8000 for frontend, 11111 for worker)"
-    ),
-    host: str = typer.Option("0.0.0.0", help="Host to bind to (frontend only)"),  # noqa: S104
-    workers_count: int = typer.Option(
-        1, "--workers", help="Number of worker processes"
-    ),
-) -> None:
-    """Run in development mode with hot reload (frontend or worker)."""
-    os.environ["DEBUG"] = "1"
 
-    if service == "worker":
-        # Worker mode
-        from streaq.cli import main as streaq_main
+def _compute_auto_port() -> int:
+    """Compute deterministic port from current directory path."""
+    cwd = os.getcwd()
+    hash_bytes = hashlib.sha256(cwd.encode()).digest()
+    hash_int = int.from_bytes(hash_bytes[:4], "big")
+    return 8001 + (hash_int % 999)
 
-        worker_port = port if port else 11111
-        console.print(
-            f"[green]Starting worker in dev mode on port {worker_port}[/green]"
-        )
-        console.print("[dim]Hot reload enabled[/dim]")
 
-        if workers_count > 1:
-            console.print(
-                "[yellow]Warning: Multiple workers not supported in dev mode, using 1[/yellow]"
-            )
-
-        # Call streaq programmatically
-        streaq_main(
-            worker_path="vibetuner.tasks.worker.worker",
-            workers=1,
-            reload=True,
-            verbose=True,
-            web=True,
-            host="0.0.0.0",  # noqa: S104
-            port=worker_port,
+def _run_worker(mode: Literal["dev", "prod"], port: int, workers: int) -> None:
+    """Start the background worker process."""
+    from streaq.cli import main as streaq_main
+
+    from vibetuner.config import settings
+
+    if not settings.workers_available:
+        logger.warning("Redis URL not configured. Workers will not be started.")
+        console.print(
+            "[red]Error: Redis URL not configured. Workers will not be started.[/red]"
         )
-    elif service == "frontend":
-        # Frontend mode
-        from pathlib import Path
+        raise typer.Exit(code=0)
 
-        from granian import Granian
-        from granian.constants import Interfaces
+    is_dev = mode == "dev"
 
-        frontend_port = port if port else 8000
+    if is_dev and workers > 1:
         console.print(
-            f"[green]Starting frontend in dev mode on {host}:{frontend_port}[/green]"
+            "[yellow]Warning: Multiple workers not supported in dev mode, using 1[/yellow]"
         )
+        workers = 1
+
+    console.print(f"[green]Starting worker in {mode} mode on port {port}[/green]")
+    if is_dev:
+        console.print("[dim]Hot reload enabled[/dim]")
+    else:
+        console.print(f"[dim]Workers: {workers}[/dim]")
+
+    streaq_main(
+        worker_path="vibetuner.tasks.worker.worker",
+        workers=workers,
+        reload=is_dev,
+        verbose=True if is_dev else settings.debug,
+        web=True,
+        host="0.0.0.0",  # noqa: S104
+        port=port,
+    )
+
+
+def _run_frontend(
+    mode: Literal["dev", "prod"], host: str, port: int, workers: int
+) -> None:
+    """Start the frontend server."""
+    from granian import Granian
+    from granian.constants import Interfaces
+
+    is_dev = mode == "dev"
+
+    console.print(f"[green]Starting frontend in {mode} mode on {host}:{port}[/green]")
+    console.print(f"[cyan]website reachable at http://localhost:{port}[/cyan]")
+    console.print(
+        f"[cyan]website reachable at https://{port}.localdev.alltuner.com:12000/[/cyan]"
+    )
+    if is_dev:
         console.print("[dim]Watching for changes in src/ and templates/[/dim]")
+    else:
+        console.print(f"[dim]Workers: {workers}[/dim]")
 
-        # Define paths to watch for changes
-        reload_paths = [
+    reload_paths = (
+        [
             Path("src/app"),
             Path("templates/frontend"),
             Path("templates/email"),
             Path("templates/markdown"),
         ]
-
-        server = Granian(
-            target="vibetuner.frontend:app",
-            address=host,
-            port=frontend_port,
-            interface=Interfaces.ASGI,
-            workers=workers_count,
-            reload=True,
-            reload_paths=reload_paths,
-            log_level="info",
-            log_access=True,
-        )
-
-        server.serve()
+        if is_dev
+        else None
+    )
+
+    server = Granian(
+        target="vibetuner.frontend.proxy:app",
+        address=host,
+        port=port,
+        interface=Interfaces.ASGI,
+        workers=workers,
+        reload=is_dev,
+        reload_paths=reload_paths,
+        log_level="info",
+        log_access=True,
+    )
+
+    server.serve()
+
+
+def _run_service(
+    mode: Literal["dev", "prod"],
+    service: str,
+    host: str,
+    port: int | None,
+    workers: int,
+) -> None:
+    """Dispatch to the appropriate service runner."""
+    if service == "worker":
+        _run_worker(mode, port or DEFAULT_WORKER_PORT, workers)
+    elif service == "frontend":
+        _run_frontend(mode, host, port or DEFAULT_FRONTEND_PORT, workers)
     else:
         console.print(f"[red]Error: Unknown service '{service}'[/red]")
         console.print("[yellow]Valid services: 'frontend' or 'worker'[/yellow]")
         raise typer.Exit(code=1)
 
 
+@run_app.command(name="dev")
+def dev(
+    service: Annotated[
+        str, typer.Argument(help="Service to run: 'frontend' or 'worker'")
+    ] = "frontend",
+    port: int | None = typer.Option(
+        None, help="Port to run on (8000 for frontend, 11111 for worker)"
+    ),
+    auto_port: bool = typer.Option(
+        False,
+        "--auto-port",
+        help="Use deterministic port based on project path (8001-8999)",
+    ),
+    host: str = typer.Option("0.0.0.0", help="Host to bind to (frontend only)"),  # noqa: S104
+    workers_count: int = typer.Option(
+        1, "--workers", help="Number of worker processes"
+    ),
+) -> None:
+    """Run in development mode with hot reload (frontend or worker)."""
+    if port is not None and auto_port:
+        console.print("[red]Error: --port and --auto-port are mutually exclusive[/red]")
+        raise typer.Exit(code=1)
+
+    if auto_port:
+        port = _compute_auto_port()
+
+    _run_service("dev", service, host, port, workers_count)
+
+
 @run_app.command(name="prod")
 def prod(
     service: Annotated[
@@ -109,52 +173,4 @@ def prod(
     ),
 ) -> None:
     """Run in production mode (frontend or worker)."""
-    os.environ["ENVIRONMENT"] = "production"
-
-    if service == "worker":
-        # Worker mode
-        from streaq.cli import main as streaq_main
-
-        worker_port = port if port else 11111
-        console.print(
-            f"[green]Starting worker in prod mode on port {worker_port}[/green]"
-        )
-        console.print(f"[dim]Workers: {workers_count}[/dim]")
-
-        # Call streaq programmatically
-        streaq_main(
-            worker_path="vibetuner.tasks.worker.worker",
-            workers=workers_count,
-            reload=False,
-            verbose=False,
-            web=True,
-            host="0.0.0.0",  # noqa: S104
-            port=worker_port,
-        )
-    elif service == "frontend":
-        # Frontend mode
-        from granian import Granian
-        from granian.constants import Interfaces
-
-        frontend_port = port if port else 8000
-        console.print(
-            f"[green]Starting frontend in prod mode on {host}:{frontend_port}[/green]"
-        )
-        console.print(f"[dim]Workers: {workers_count}[/dim]")
-
-        server = Granian(
-            target="vibetuner.frontend:app",
-            address=host,
-            port=frontend_port,
-            interface=Interfaces.ASGI,
-            workers=workers_count,
-            reload=False,
-            log_level="info",
-            log_access=True,
-        )
-
-        server.serve()
-    else:
-        console.print(f"[red]Error: Unknown service '{service}'[/red]")
-        console.print("[yellow]Valid services: 'frontend' or 'worker'[/yellow]")
-        raise typer.Exit(code=1)
+    _run_service("prod", service, host, port, workers_count)

vibetuner/cli/scaffold.py

@@ -10,6 +10,7 @@ from rich.console import Console
 
 console = Console()
 
+
 scaffold_app = typer.Typer(
     help="Create new projects from the vibetuner template", no_args_is_help=True
 )
@@ -185,3 +186,9 @@ def update(
     except Exception as e:
         console.print(f"[red]Error updating project: {e}[/red]")
         raise typer.Exit(code=1) from None
+
+
+@scaffold_app.command(name="copy-core-templates", hidden=True)
+def copy_core_templates() -> None:
+    """Deprecated: This command is a no-op kept for backwards compatibility."""
+    console.print("[dim]This command is deprecated and does nothing.[/dim]")

vibetuner/config.py

@@ -2,16 +2,21 @@ import base64
 import hashlib
 from datetime import datetime
 from functools import cached_property
-from typing import Annotated
+from typing import Annotated, Literal
 
 import yaml
 from pydantic import (
     UUID4,
+    AnyUrl,
     Field,
     HttpUrl,
+    MariaDBDsn,
     MongoDsn,
+    MySQLDsn,
+    PostgresDsn,
     RedisDsn,
     SecretStr,
+    UrlConstraints,
     computed_field,
 )
 from pydantic_extra_types.language_code import LanguageAlpha2
@@ -23,6 +28,24 @@ from .paths import config_vars as config_vars_path
 from .versioning import version
 
 
+class SQLiteDsn(AnyUrl):
+    """A type that will accept any SQLite DSN.
+
+    * User info not required
+    * TLD not required
+    * Host not required (file-based database)
+    """
+
+    _constraints = UrlConstraints(
+        allowed_schemes=[
+            "sqlite",
+            "sqlite+aiosqlite",
+            "sqlite+pysqlite",
+        ],
+        host_required=False,
+    )
+
+
 current_year: int = datetime.now().year
 
 
@@ -100,12 +123,15 @@ class CoreConfiguration(BaseSettings):
     project: ProjectConfiguration = ProjectConfiguration.from_project_config()
 
     debug: bool = False
+    environment: Literal["dev", "prod"] = "dev"
     version: str = version
     session_key: SecretStr = SecretStr("ct-!secret-must-change-me")
+    debug_access_token: str | None = None
 
     # Database and Cache URLs
-    mongodb_url: MongoDsn = MongoDsn("mongodb://localhost:27017")
-    redis_url: RedisDsn = RedisDsn("redis://localhost:6379")
+    mongodb_url: MongoDsn | None = None
+    redis_url: RedisDsn | None = None
+    database_url: PostgresDsn | MariaDBDsn | MySQLDsn | SQLiteDsn | None = None
 
     aws_access_key_id: SecretStr | None = None
     aws_secret_access_key: SecretStr | None = None
@@ -116,6 +142,18 @@ class CoreConfiguration(BaseSettings):
     r2_secret_key: SecretStr | None = None
     r2_default_region: str = "auto"
 
+    worker_concurrency: int = 16
+
+    # Proxy configuration for X-Forwarded-For/Proto headers
+    # Comma-separated list of trusted proxy IPs/CIDRs (e.g., "127.0.0.1,192.168.1.0/24")
+    # SECURITY: Only IPs in this list can set forwarded headers. Use "*" to trust all (NOT recommended for production)
+    trusted_proxy_hosts: str = "127.0.0.1"
+
+    @cached_property
+    def trusted_proxy_hosts_list(self) -> list[str]:
+        """Parse trusted proxy hosts into a list for Granian's proxy header wrapper."""
+        return [h.strip() for h in self.trusted_proxy_hosts.split(",") if h.strip()]
+
     @computed_field
     @cached_property
     def v_hash(self) -> str:
@@ -128,10 +166,24 @@ class CoreConfiguration(BaseSettings):
 
         return url_safe_hash
 
+    @property
+    def workers_available(self) -> bool:
+        return self.redis_url is not None
+
     @cached_property
     def mongo_dbname(self) -> str:
         return self.project.project_slug
 
+    @cached_property
+    def redis_key_prefix(self) -> str:
+        """Returns the Redis key prefix for namespacing all Redis keys by project and environment.
+
+        Format: "{project_slug}:{env}:" for dev, "{project_slug}:" for prod.
+        """
+        if self.environment == "dev":
+            return f"{self.project.project_slug}:dev:"
+        return f"{self.project.project_slug}:"
+
     model_config = SettingsConfigDict(
         case_sensitive=False, extra="ignore", env_file=".env"
     )

vibetuner/frontend/__init__.py

@@ -117,5 +117,6 @@ def default_index(request: Request) -> HTMLResponse:
     return render_template("index.html.jinja", request)
 
 
+app.include_router(debug.auth_router)
 app.include_router(debug.router)
 app.include_router(health.router)

vibetuner/frontend/lifespan.py

@@ -5,7 +5,8 @@ from fastapi import FastAPI
 
 from vibetuner.context import ctx
 from vibetuner.logging import logger
-from vibetuner.mongo import init_models
+from vibetuner.mongo import init_mongodb, teardown_mongodb
+from vibetuner.sqlmodel import init_sqlmodel, teardown_sqlmodel
 
 from .hotreload import hotreload
 
@@ -16,7 +17,8 @@ async def base_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     if ctx.DEBUG:
         await hotreload.startup()
 
-    await init_models()
+    await init_mongodb()
+    await init_sqlmodel()
 
     yield
 
@@ -25,6 +27,9 @@ async def base_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
         await hotreload.shutdown()
     logger.info("Vibetuner frontend stopped")
 
+    await teardown_sqlmodel()
+    await teardown_mongodb()
+
 
 try:
     from app.frontend.lifespan import lifespan  # ty: ignore

vibetuner/frontend/middleware.py

@@ -6,7 +6,6 @@ from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware.sessions import SessionMiddleware
 from starlette.middleware.trustedhost import TrustedHostMiddleware
-from starlette.types import ASGIApp, Receive, Scope, Send
 from starlette_babel import (
     LocaleFromCookie,
     LocaleFromQuery,
@@ -84,29 +83,6 @@ class AdjustLangCookieMiddleware(BaseHTTPMiddleware):
         return response
 
 
-class ForwardedProtocolMiddleware:
-    def __init__(self, app: ASGIApp):
-        self.app = app
-
-    # Based on https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] == "lifespan":
-            return await self.app(scope, receive, send)
-
-        headers = dict(scope["headers"])
-
-        if b"x-forwarded-proto" in headers:
-            x_forwarded_proto = headers[b"x-forwarded-proto"].decode("latin1").strip()
-
-            if x_forwarded_proto in {"http", "https", "ws", "wss"}:
-                if scope["type"] == "websocket":
-                    scope["scheme"] = x_forwarded_proto.replace("http", "ws")
-                else:
-                    scope["scheme"] = x_forwarded_proto
-
-        return await self.app(scope, receive, send)
-
-
 class AuthBackend(AuthenticationBackend):
     async def authenticate(
         self,
@@ -128,7 +104,6 @@ class AuthBackend(AuthenticationBackend):
 
 middlewares: list[Middleware] = [
     Middleware(TrustedHostMiddleware),
-    Middleware(ForwardedProtocolMiddleware),
     Middleware(HtmxMiddleware),
     Middleware(SessionMiddleware, secret_key=settings.session_key.get_secret_value()),
     Middleware(

vibetuner/frontend/proxy.py

@@ -0,0 +1,14 @@
+# ABOUTME: ASGI app wrapper that processes X-Forwarded-For and X-Forwarded-Proto headers
+# ABOUTME: Uses Granian's proxy header support to extract real client IP and protocol
+from granian.utils.proxies import wrap_asgi_with_proxy_headers
+
+from vibetuner.config import settings
+from vibetuner.frontend import app as _app
+
+
+# Wrap the FastAPI app with Granian's proxy header processor
+# This enables real client IP detection when behind reverse proxies (nginx, Cloudflare, etc.)
+# Only headers from trusted_proxy_hosts will be processed to prevent IP spoofing
+app = wrap_asgi_with_proxy_headers(
+    _app, trusted_hosts=settings.trusted_proxy_hosts_list
+)