vibetuner 2.18.1__py3-none-any.whl → 2.30.1__py3-none-any.whl

vibetuner/cli/__init__.py

@@ -1,5 +1,6 @@
 # ABOUTME: Core CLI setup with AsyncTyper wrapper and base configuration
 # ABOUTME: Provides main CLI entry point and logging configuration
+import importlib.metadata
 import inspect
 from functools import partial, wraps
 from importlib import import_module
@@ -7,10 +8,11 @@ from importlib import import_module
 import asyncer
 import typer
 from rich.console import Console
+from rich.table import Table
 
 from vibetuner.cli.run import run_app
 from vibetuner.cli.scaffold import scaffold_app
-from vibetuner.logging import LogLevel, setup_logging
+from vibetuner.logging import LogLevel, logger, setup_logging
 
 
 console = Console()
@@ -69,11 +71,54 @@ def callback(log_level: LogLevel | None = LOG_LEVEL_OPTION) -> None:
     setup_logging(level=log_level)
 
 
+@app.command()
+def version(
+    show_app: bool = typer.Option(
+        False,
+        "--app",
+        "-a",
+        help="Show app settings version even if not in a project directory",
+    ),
+) -> None:
+    """Show version information."""
+    try:
+        # Get vibetuner package version
+        vibetuner_version = importlib.metadata.version("vibetuner")
+    except importlib.metadata.PackageNotFoundError:
+        vibetuner_version = "unknown"
+
+    # Create table for nice display
+    table = Table(title="Version Information")
+    table.add_column("Component", style="cyan", no_wrap=True)
+    table.add_column("Version", style="green", no_wrap=True)
+
+    # Always show vibetuner package version
+    table.add_row("vibetuner package", vibetuner_version)
+
+    # Show app version if requested or if in a project
+    try:
+        from vibetuner.config import CoreConfiguration
+
+        settings = CoreConfiguration()
+        table.add_row(f"{settings.project.project_name} settings", settings.version)
+    except Exception:
+        if show_app:
+            table.add_row("app settings", "not in project directory")
+        # else: don't show app version if not in project and not requested
+
+    console.print(table)
+
+
 app.add_typer(run_app, name="run")
 app.add_typer(scaffold_app, name="scaffold")
 
 try:
     import_module("app.cli")
-except (ImportError, ModuleNotFoundError):
+except ModuleNotFoundError:
+    # Silent pass for missing app.cli module (expected in some projects)
     pass
-# Cache buster
+except ImportError as e:
+    # Log warning for any import error (including syntax errors, missing dependencies, etc.)
+    logger.warning(
+        f"Failed to import app.cli: {e}. User CLI commands will not be available."
+    )

vibetuner/cli/run.py

@@ -47,7 +47,7 @@ def dev(
 
         # Call streaq programmatically
         streaq_main(
-            worker_path="app.tasks.worker.worker",
+            worker_path="vibetuner.tasks.worker.worker",
             workers=1,
             reload=True,
             verbose=True,
@@ -123,7 +123,7 @@ def prod(
 
         # Call streaq programmatically
         streaq_main(
-            worker_path="app.tasks.worker.worker",
+            worker_path="vibetuner.tasks.worker.worker",
             workers=workers_count,
             reload=False,
             verbose=False,

vibetuner/cli/scaffold.py

@@ -185,3 +185,28 @@ 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="link")
+def link(
+    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.
+
+    This command creates a symlink from the specified target path to the core
+    templates directory in the vibetuner package. It is used during development
+    to enable Tailwind and other build tools to scan core templates.
+
+    Examples:
+
+        # Create symlink in templates/core
+        vibetuner scaffold link templates/core
+    """
+    from vibetuner.paths import create_core_templates_symlink
+
+    create_core_templates_symlink(target)

vibetuner/config.py

@@ -2,7 +2,7 @@ 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 (
@@ -100,8 +100,10 @@ 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")
@@ -132,6 +134,16 @@ class CoreConfiguration(BaseSettings):
     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"
     )
@@ -141,4 +153,3 @@ settings = CoreConfiguration()
 
 
 logger.info("Configuration loaded for project: {}", settings.project.project_name)
-logger.info("Configuration loaded for project: {}", settings.model_dump())

vibetuner/frontend/__init__.py

@@ -4,10 +4,12 @@ from fastapi import APIRouter, Depends as Depends, FastAPI, Request
 from fastapi.responses import HTMLResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 
+import vibetuner.frontend.lifespan as lifespan_module
 from vibetuner import paths
+from vibetuner.logging import logger
 
 from .deps import LangDep as LangDep, MagicCookieDep as MagicCookieDep
-from .lifespan import ctx, lifespan
+from .lifespan import ctx
 from .middleware import middlewares
 from .routes import auth, debug, health, language, meta, user
 from .templates import render_template
@@ -21,15 +23,35 @@ def register_router(router: APIRouter) -> None:
 
 
 try:
-    import app.frontend.oauth as _app_oauth  # noqa: F401  # type: ignore[unresolved-import]
-    import app.frontend.routes as _app_routes  # noqa: F401  # type: ignore[unresolved-import]
+    import app.frontend.oauth as _app_oauth  # type: ignore[unresolved-import] # noqa: F401
+    import app.frontend.routes as _app_routes  # type: ignore[unresolved-import] # noqa: F401
 
     # Register OAuth routes after providers are registered
     from .routes.auth import register_oauth_routes
 
     register_oauth_routes()
-except (ImportError, ModuleNotFoundError):
+except ModuleNotFoundError:
+    # Silent pass for missing app.frontend.oauth or app.frontend.routes modules (expected in some projects)
     pass
+except ImportError as e:
+    # Log warning for any import error (including syntax errors, missing dependencies, etc.)
+    logger.warning(
+        f"Failed to import app.frontend.oauth or app.frontend.routes: {e}. OAuth and custom routes will not be available."
+    )
+
+try:
+    from app.frontend.middleware import (
+        middlewares as app_middlewares,  # type: ignore[unresolved-import]
+    )
+
+    middlewares.extend(app_middlewares)
+except ModuleNotFoundError:
+    pass
+except ImportError as e:
+    # Log warning for any import error (including syntax errors, missing dependencies, etc.)
+    logger.warning(
+        f"Failed to import app.frontend.middleware: {e}. Additional middlewares will not be available."
+    )
 
 
 dependencies: list[Any] = [
@@ -38,7 +60,7 @@ dependencies: list[Any] = [
 
 app = FastAPI(
     debug=ctx.DEBUG,
-    lifespan=lifespan,
+    lifespan=lifespan_module.lifespan,
     docs_url=None,
     redoc_url=None,
     openapi_url=None,
@@ -95,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

@@ -1,4 +1,5 @@
 from contextlib import asynccontextmanager
+from typing import AsyncGenerator
 
 from fastapi import FastAPI
 
@@ -10,7 +11,7 @@ from .hotreload import hotreload
 
 
 @asynccontextmanager
-async def base_lifespan(app: FastAPI):
+async def base_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     logger.info("Vibetuner frontend starting")
     if ctx.DEBUG:
         await hotreload.startup()
@@ -27,5 +28,10 @@ async def base_lifespan(app: FastAPI):
 
 try:
     from app.frontend.lifespan import lifespan  # ty: ignore
-except ImportError:
+except ModuleNotFoundError:
+    # Silent pass for missing app.frontend.lifespan module (expected in some projects)
+    lifespan = base_lifespan
+except ImportError as e:
+    # Log warning for any import error (including syntax errors, missing dependencies, etc.)
+    logger.warning(f"Failed to import app.frontend.lifespan: {e}. Using base lifespan.")
     lifespan = base_lifespan

vibetuner/frontend/middleware.py

@@ -126,7 +126,6 @@ class AuthBackend(AuthenticationBackend):
         return None
 
 
-# Until this line
 middlewares: list[Middleware] = [
     Middleware(TrustedHostMiddleware),
     Middleware(ForwardedProtocolMiddleware),
@@ -145,7 +144,4 @@ middlewares: list[Middleware] = [
     ),
     Middleware(AdjustLangCookieMiddleware),
     Middleware(AuthenticationMiddleware, backend=AuthBackend()),
-    # Add your middleware below this line
 ]
-
-# EOF

vibetuner/frontend/routes/debug.py

@@ -3,13 +3,13 @@ from fastapi import (
     Depends,
     HTTPException,
     Request,
-    Response,
 )
 from fastapi.responses import (
     HTMLResponse,
     RedirectResponse,
 )
 
+from vibetuner.config import settings
 from vibetuner.context import ctx
 from vibetuner.models import UserModel
 from vibetuner.models.registry import get_all_models
@@ -18,32 +18,41 @@ from ..deps import MAGIC_COOKIE_NAME
 from ..templates import render_template
 
 
-def check_debug_access(request: Request, prod: str | None = None):
+def check_debug_access(request: Request):
     """Check if debug routes should be accessible."""
     # Always allow in development mode
     if ctx.DEBUG:
         return True
 
-    # In production, require prod=1 parameter
-    if prod == "1":
-        return True
+    # In production, require magic cookie
+    if MAGIC_COOKIE_NAME not in request.cookies:
+        raise HTTPException(status_code=404, detail="Not found")
+    if request.cookies[MAGIC_COOKIE_NAME] != "granted":
+        raise HTTPException(status_code=404, detail="Not found")
 
-    # Deny access
-    raise HTTPException(status_code=404, detail="Not found")
+    return True
 
 
-router = APIRouter(prefix="/debug", dependencies=[Depends(check_debug_access)])
+# Unprotected router for token-based debug access
+auth_router = APIRouter()
 
 
-@router.get("/", response_class=HTMLResponse)
-def debug_index(request: Request):
-    return render_template("debug/index.html.jinja", request)
+@auth_router.get("/_unlock-debug")
+def unlock_debug_access(token: str | None = None):
+    """Grant debug access by setting the magic cookie.
 
+    In DEBUG mode, no token is required.
+    In production, the token must match DEBUG_ACCESS_TOKEN.
+    If DEBUG_ACCESS_TOKEN is not configured, debug access is disabled in production.
+    """
+    if not ctx.DEBUG:
+        # In production, validate token
+        if settings.debug_access_token is None:
+            raise HTTPException(status_code=404, detail="Not found")
+        if token is None or token != settings.debug_access_token:
+            raise HTTPException(status_code=404, detail="Not found")
 
-@router.get("/magic")
-def set_magic_cookie(response: Response):
-    """Set the magic access cookie."""
-    response = RedirectResponse(url="/", status_code=302)
+    response = RedirectResponse(url="/debug", status_code=302)
     response.set_cookie(
         key=MAGIC_COOKIE_NAME,
         value="granted",
@@ -55,14 +64,23 @@ def set_magic_cookie(response: Response):
     return response
 
 
-@router.get("/no-magic")
-def remove_magic_cookie(response: Response):
-    """Remove the magic access cookie."""
+@auth_router.get("/_lock-debug")
+def lock_debug_access():
+    """Revoke debug access by removing the magic cookie."""
     response = RedirectResponse(url="/", status_code=302)
     response.delete_cookie(key=MAGIC_COOKIE_NAME)
     return response
 
 
+# Protected router for debug endpoints requiring cookie auth
+router = APIRouter(prefix="/debug", dependencies=[Depends(check_debug_access)])
+
+
+@router.get("/", response_class=HTMLResponse)
+def debug_index(request: Request):
+    return render_template("debug/index.html.jinja", request)
+
+
 @router.get("/version", response_class=HTMLResponse)
 def debug_version(request: Request):
     return render_template("debug/version.html.jinja", request)
@@ -136,20 +154,11 @@ def _is_beanie_link_schema(option: dict) -> bool:
 
 def _infer_link_target_from_field_name(field_name: str) -> str:
     """Infer the target model type from field name patterns."""
-    # Common patterns for field names that reference other models
+    # Core vibetuner models
     patterns = {
         "oauth_accounts": "OAuthAccountModel",
-        "accounts": "AccountModel",
         "users": "UserModel",
         "user": "UserModel",
-        "stations": "StationModel",
-        "station": "StationModel",
-        "rundowns": "RundownModel",
-        "rundown": "RundownModel",
-        "fillers": "FillerModel",
-        "filler": "FillerModel",
-        "voices": "VoiceModel",
-        "voice": "VoiceModel",
         "blobs": "BlobModel",
         "blob": "BlobModel",
     }
@@ -374,10 +383,13 @@ async def debug_users(request: Request):
     )
 
 
+# The following endpoints are restricted to DEBUG mode only (no production access).
+# These are dangerous operations that could compromise security if allowed in production.
+
+
 @router.post("/impersonate/{user_id}")
 async def debug_impersonate_user(request: Request, user_id: str):
     """Impersonate a user by setting their ID in the session."""
-    # Double check debug mode for security
     if not ctx.DEBUG:
         raise HTTPException(status_code=404, detail="Not found")
 
@@ -395,7 +407,6 @@ async def debug_impersonate_user(request: Request, user_id: str):
 @router.post("/stop-impersonation")
 async def debug_stop_impersonation(request: Request):
     """Stop impersonating and clear user session."""
-    # Double check debug mode for security
     if not ctx.DEBUG:
         raise HTTPException(status_code=404, detail="Not found")
 
@@ -406,7 +417,6 @@ async def debug_stop_impersonation(request: Request):
 @router.get("/clear-session")
 async def debug_clear_session(request: Request):
     """Clear all session data to fix corrupted sessions."""
-    # Double check debug mode for security
     if not ctx.DEBUG:
         raise HTTPException(status_code=404, detail="Not found")
 

vibetuner/frontend/templates.py

@@ -7,7 +7,7 @@ from starlette.responses import HTMLResponse
 from starlette_babel import gettext_lazy as _, gettext_lazy as ngettext
 from starlette_babel.contrib.jinja import configure_jinja_env
 
-from vibetuner.context import Context
+from vibetuner.context import ctx as data_ctx
 from vibetuner.paths import frontend_templates
 from vibetuner.templates import render_static_template
 from vibetuner.time import age_in_timedelta
@@ -17,9 +17,36 @@ from .hotreload import hotreload
 
 __all__ = [
     "render_static_template",
+    "register_filter",
 ]
 
-data_ctx = Context()
+
+_filter_registry: dict[str, Any] = {}
+
+
+def register_filter(name: str | None = None):
+    """Decorator to register a custom Jinja2 filter.
+
+    Args:
+        name: Optional custom name for the filter. If not provided,
+              uses the function name.
+
+    Usage:
+        @register_filter()
+        def my_filter(value):
+            return value.upper()
+
+        @register_filter("custom_name")
+        def another_filter(value):
+            return value.lower()
+    """
+
+    def decorator(func):
+        filter_name = name or func.__name__
+        _filter_registry[filter_name] = func
+        return func
+
+    return decorator
 
 
 def timeago(dt):
@@ -173,4 +200,22 @@ jinja_env.filters["format_datetime"] = format_datetime
 jinja_env.filters["format_duration"] = format_duration
 jinja_env.filters["duration"] = format_duration
 
+# Import user-defined filters to trigger registration
+try:
+    import app.frontend.templates as _app_templates  # type: ignore[import-not-found] # noqa: F401
+except ModuleNotFoundError:
+    # Silent pass - templates module is optional
+    pass
+except ImportError as e:
+    from vibetuner.logging import logger
+
+    logger.warning(
+        f"Failed to import app.frontend.templates: {e}. Custom filters will not be available."
+    )
+
+# Apply all registered custom filters
+for filter_name, filter_func in _filter_registry.items():
+    jinja_env.filters[filter_name] = filter_func
+
+# Configure Jinja environment after all filters are registered
 configure_jinja_env(jinja_env)

vibetuner/mongo.py

@@ -1,13 +1,28 @@
+from importlib import import_module
+
 from beanie import init_beanie
 from pymongo import AsyncMongoClient
 
 from vibetuner.config import settings
+from vibetuner.logging import logger
 from vibetuner.models.registry import get_all_models
 
 
 async def init_models() -> None:
     """Initialize MongoDB connection and register all Beanie models."""
 
+    # Try to import user models to trigger their registration
+    try:
+        import_module("app.models")
+    except ModuleNotFoundError:
+        # Silent pass for missing app.models module (expected in some projects)
+        pass
+    except ImportError as e:
+        # Log warning for any import error (including syntax errors, missing dependencies, etc.)
+        logger.warning(
+            f"Failed to import app.models: {e}. User models will not be registered."
+        )
+
     client: AsyncMongoClient = AsyncMongoClient(
         host=str(settings.mongodb_url),
         compressors=["zstd"],

vibetuner/paths.py

@@ -5,6 +5,8 @@ from typing import Self
 from pydantic import computed_field, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+from vibetuner.logging import logger
+
 
 # Package-relative paths (for bundled templates in the vibetuner package)
 _package_files = files("vibetuner")
@@ -22,6 +24,38 @@ def _get_package_templates_path() -> Path:
         ) from None
 
 
+def create_core_templates_symlink(target: Path) -> None:
+    """Create or update a 'core' symlink pointing to the package templates directory."""
+
+    try:
+        source = _get_package_templates_path().resolve()
+    except RuntimeError as e:
+        logger.error(f"Cannot create symlink: {e}")
+        return
+
+    # Case 1: target is already a symlink → check if it needs updating
+    if target.is_symlink():
+        if target.resolve() != source:
+            target.unlink()
+            target.symlink_to(source, target_is_directory=True)
+            logger.info(f"Updated symlink '{target}' → '{source}'")
+        else:
+            logger.debug(f"Symlink '{target}' already points to '{source}'")
+        return
+
+    # Case 2: target does not exist → create symlink
+    if not target.exists():
+        target.symlink_to(source, target_is_directory=True)
+        logger.info(f"Created symlink '{target}' → '{source}'")
+        return
+
+    # Case 3: exists but is not a symlink → error
+    logger.error(f"Cannot create symlink: '{target}' exists and is not a symlink.")
+    raise FileExistsError(
+        f"Cannot create symlink: '{target}' exists and is not a symlink."
+    )
+
+
 # Package templates always available
 package_templates = _get_package_templates_path()
 core_templates = package_templates  # Alias for backwards compatibility
@@ -158,10 +192,6 @@ class PathSettings(BaseSettings):
         paths.append(package_templates / "markdown")
         return paths
 
-    def set_root(self, project_root: Path) -> None:
-        """Explicitly set project root (overrides auto-detection)."""
-        self.root = project_root
-
     def to_template_path_list(self, path: Path) -> list[Path]:
         """Convert path to list with fallback."""
         return [path, path / self.fallback_path]
@@ -191,12 +221,6 @@ class PathSettings(BaseSettings):
 _settings = PathSettings()
 
 
-# Backwards-compatible module-level API
-def set_project_root(project_root: Path) -> None:
-    """Set the project root directory explicitly."""
-    _settings.set_root(project_root)
-
-
 def to_template_path_list(path: Path) -> list[Path]:
     """Convert path to list with fallback."""
     return _settings.to_template_path_list(path)