@weirdfingers/baseboards 0.2.0

package/templates/api/src/boards/cli.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""
+Main CLI entry point for Boards backend server.
+"""
+
+import os
+import sys
+
+import click
+import uvicorn
+
+from boards import __version__
+from boards.logging import configure_logging, get_logger
+
+logger = get_logger(__name__)
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="boards")
+def cli() -> None:
+    """Boards CLI - manage server, database, and tenants."""
+    pass
+
+
+@cli.command()
+@click.option(
+    "--host",
+    default="0.0.0.0",
+    help="Host to bind to (default: 0.0.0.0)",
+)
+@click.option(
+    "--port",
+    default=8088,
+    type=int,
+    help="Port to bind to (default: 8088)",
+)
+@click.option(
+    "--reload",
+    is_flag=True,
+    default=False,
+    help="Enable auto-reload for development",
+)
+@click.option(
+    "--workers",
+    default=1,
+    type=int,
+    help="Number of worker processes (default: 1)",
+)
+@click.option(
+    "--log-level",
+    default="info",
+    type=click.Choice(["debug", "info", "warning", "error"]),
+    help="Log level (default: info)",
+)
+def serve(
+    host: str,
+    port: int,
+    reload: bool,
+    workers: int,
+    log_level: str,
+) -> None:
+    """Start the Boards API server."""
+
+    # Configure logging
+    configure_logging(debug=(log_level == "debug"))
+
+    logger.info(
+        "Starting Boards API server",
+        host=host,
+        port=port,
+        reload=reload,
+        workers=workers,
+        log_level=log_level,
+    )
+
+    # Set environment variables for app configuration when using reload/workers
+    # This ensures the app imports with the correct settings
+    if log_level == "debug":
+        os.environ["BOARDS_DEBUG"] = "true"
+        os.environ["BOARDS_LOG_LEVEL"] = "debug"
+    else:
+        os.environ.setdefault("BOARDS_DEBUG", "false")
+        os.environ.setdefault("BOARDS_LOG_LEVEL", log_level)
+
+    try:
+        # When using reload or multiple workers, pass app as import string
+        if reload or workers > 1:
+            uvicorn.run(
+                "boards.api.app:app",
+                host=host,
+                port=port,
+                reload=reload,
+                workers=(workers if not reload else 1),  # reload doesn't work with multiple workers
+                log_level=log_level,
+                access_log=True,
+            )
+        else:
+            # Import app directly when not using reload/workers
+            from boards.api.app import app
+
+            uvicorn.run(
+                app,
+                host=host,
+                port=port,
+                reload=reload,
+                workers=workers,
+                log_level=log_level,
+                access_log=True,
+            )
+    except KeyboardInterrupt:
+        logger.info("Server shutdown requested by user")
+    except Exception as e:
+        logger.error("Server startup failed", error=str(e))
+        sys.exit(1)
+
+
+@cli.group()
+def tenant() -> None:
+    """Manage tenants in the database."""
+    pass
+
+
+@tenant.command("create")
+@click.option(
+    "--name",
+    required=True,
+    help="Display name for the tenant",
+)
+@click.option(
+    "--slug",
+    required=True,
+    help="Unique slug for the tenant (used in URLs)",
+)
+@click.option(
+    "--sample-data",
+    is_flag=True,
+    default=False,
+    help="Include sample data for the tenant",
+)
+def create_tenant(
+    name: str,
+    slug: str,
+    sample_data: bool,
+) -> None:
+    """Create a new tenant in the database."""
+    import asyncio
+
+    from boards.database.connection import get_async_session
+    from boards.database.seed_data import seed_tenant_with_data
+
+    configure_logging()
+
+    async def do_create():
+        async with get_async_session() as db:
+            try:
+                tenant_id = await seed_tenant_with_data(
+                    db,
+                    tenant_name=name,
+                    tenant_slug=slug,
+                    include_sample_data=sample_data,
+                )
+                logger.info(
+                    "Tenant created successfully",
+                    tenant_id=str(tenant_id),
+                    name=name,
+                    slug=slug,
+                )
+                click.echo(f"✓ Tenant created: {tenant_id}")
+                click.echo(f"  Name: {name}")
+                click.echo(f"  Slug: {slug}")
+                if sample_data:
+                    click.echo("  Sample data: included")
+            except Exception as e:
+                logger.error("Failed to create tenant", error=str(e))
+                click.echo(f"✗ Error creating tenant: {e}", err=True)
+                sys.exit(1)
+
+    asyncio.run(do_create())
+
+
+@tenant.command("list")
+def list_tenants() -> None:
+    """List all tenants in the database."""
+    import asyncio
+
+    from sqlalchemy import select
+
+    from boards.database.connection import get_async_session
+    from boards.dbmodels import Tenants
+
+    configure_logging()
+
+    async def do_list():
+        async with get_async_session() as db:
+            try:
+                stmt = select(Tenants).order_by(Tenants.created_at)
+                result = await db.execute(stmt)
+                tenants = result.scalars().all()
+
+                if not tenants:
+                    click.echo("No tenants found.")
+                else:
+                    click.echo(f"Found {len(tenants)} tenant(s):")
+                    click.echo()
+                    for t in tenants:
+                        click.echo(f"  ID: {t.id}")
+                        click.echo(f"  Name: {t.name}")
+                        click.echo(f"  Slug: {t.slug}")
+                        click.echo(f"  Created: {t.created_at}")
+                        click.echo()
+            except Exception as e:
+                logger.error("Failed to list tenants", error=str(e))
+                click.echo(f"✗ Error listing tenants: {e}", err=True)
+                sys.exit(1)
+
+    asyncio.run(do_list())
+
+
+@tenant.command("audit")
+@click.option(
+    "--tenant-slug",
+    help="Slug of specific tenant to audit (audits all if not specified)",
+)
+@click.option(
+    "--output-format",
+    default="table",
+    type=click.Choice(["table", "json"]),
+    help="Output format (default: table)",
+)
+def audit_tenant_isolation(tenant_slug: str | None, output_format: str) -> None:
+    """Audit tenant isolation for security validation."""
+    import asyncio
+    import json
+
+    from sqlalchemy import select
+
+    from boards.database.connection import get_async_session
+    from boards.dbmodels import Tenants
+    from boards.tenant_isolation import TenantIsolationValidator
+
+    configure_logging()
+
+    async def do_audit():
+        async with get_async_session() as db:
+            try:
+                validator = TenantIsolationValidator(db)
+
+                # Determine which tenants to audit
+                if tenant_slug:
+                    stmt = select(Tenants).where(Tenants.slug == tenant_slug)
+                    result = await db.execute(stmt)
+                    tenant = result.scalar_one_or_none()
+                    if not tenant:
+                        click.echo(f"✗ Tenant '{tenant_slug}' not found", err=True)
+                        sys.exit(1)
+                    tenants_to_audit = [tenant]
+                else:
+                    stmt = select(Tenants).order_by(Tenants.created_at)
+                    result = await db.execute(stmt)
+                    tenants_to_audit = result.scalars().all()
+
+                if not tenants_to_audit:
+                    click.echo("No tenants found to audit.")
+                    return
+
+                # Perform audits
+                audit_results = []
+                for tenant in tenants_to_audit:
+                    click.echo(f"🔍 Auditing tenant: {tenant.slug}")
+                    audit_result = await validator.audit_tenant_isolation(tenant.id)
+                    audit_results.append(audit_result)
+
+                # Output results
+                if output_format == "json":
+                    click.echo(json.dumps(audit_results, indent=2))
+                else:
+                    _display_audit_results_table(audit_results)
+
+            except Exception as e:
+                logger.error("Failed to audit tenant isolation", error=str(e))
+                click.echo(f"✗ Error auditing tenants: {e}", err=True)
+                sys.exit(1)
+
+    def _display_audit_results_table(results):
+        """Display audit results in table format."""
+        click.echo("\n" + "=" * 80)
+        click.echo("TENANT ISOLATION AUDIT RESULTS")
+        click.echo("=" * 80)
+
+        for result in results:
+            violations = result["isolation_violations"]
+            stats = result["statistics"]
+
+            click.echo(f"\n📋 Tenant: {result['tenant_id']}")
+            click.echo(f"   Audit Time: {result['audit_timestamp']}")
+
+            # Statistics
+            click.echo("\n📊 Statistics:")
+            click.echo(f"   Users: {stats.get('users_count', 0)}")
+            click.echo(f"   Boards: {stats.get('boards_count', 0)}")
+            click.echo(f"   Generations: {stats.get('generations_count', 0)}")
+            click.echo(f"   Board Memberships: {stats.get('board_memberships_count', 0)}")
+
+            # Violations
+            if violations:
+                click.echo(f"\n⚠️  Isolation Violations ({len(violations)}):")
+                for i, violation in enumerate(violations, 1):
+                    click.echo(f"   {i}. {violation['type']}: {violation['description']}")
+            else:
+                click.echo("\n✅ No isolation violations found")
+
+            # Recommendations
+            click.echo("\n💡 Recommendations:")
+            for rec in result["recommendations"]:
+                click.echo(f"   • {rec}")
+
+            if result != results[-1]:  # Not the last result
+                click.echo("\n" + "-" * 60)
+
+        click.echo("\n" + "=" * 80)
+
+    asyncio.run(do_audit())
+
+
+@cli.command()
+def seed() -> None:
+    """Seed the database with initial data."""
+    import asyncio
+
+    from boards.database.connection import get_async_session
+    from boards.database.seed_data import seed_initial_data
+
+    configure_logging()
+
+    async def do_seed():
+        async with get_async_session() as db:
+            try:
+                await seed_initial_data(db)
+                click.echo("✓ Database seeded successfully")
+            except Exception as e:
+                logger.error("Failed to seed database", error=str(e))
+                click.echo(f"✗ Error seeding database: {e}", err=True)
+                sys.exit(1)
+
+    asyncio.run(do_seed())
+
+
+def main():
+    """Entry point for the CLI."""
+    cli()
+
+
+if __name__ == "__main__":
+    cli()

package/templates/api/src/boards/config.py

@@ -0,0 +1,116 @@
+"""
+Configuration management for Boards backend
+"""
+
+import os
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    # Database
+    database_url: str = "postgresql://boards:boards_dev@localhost:5433/boards_dev"
+    database_pool_size: int = 10
+    database_max_overflow: int = 20
+
+    # Redis (for job queue)
+    redis_url: str = "redis://localhost:6380"
+
+    # Storage
+    storage_config_path: str | None = None
+
+    # Auth
+    auth_provider: str = "none"  # 'none', 'supabase', 'clerk', 'auth0', 'jwt'
+    auth_config: dict = {}
+    jwt_secret: str | None = None
+    jwt_algorithm: str = "HS256"
+    jwt_tenant_claim: str | None = None  # Custom JWT claim for tenant extraction
+
+    # API Settings
+    api_host: str = "0.0.0.0"
+    api_port: int = 8088
+    api_reload: bool = False
+    cors_origins: list[str] = ["http://localhost:3033"]
+
+    # Generators Configuration
+    generators_config_path: str | None = None
+    generator_api_keys: dict[str, str] = {}
+
+    # Environment
+    environment: str = "development"  # 'development', 'staging', 'production'
+    debug: bool = True
+    sql_echo: bool = False
+    log_level: str = "INFO"
+
+    # Tenant Settings (for multi-tenant mode)
+    multi_tenant_mode: bool = False
+    default_tenant_slug: str = "default"
+
+    # Tenant Registration Settings
+    tenant_registration_requires_approval: bool = False
+    tenant_registration_allowed_domains: list[str] | None = None
+    max_tenants_per_user: int | None = None
+
+    # Frontend Integration
+    frontend_base_url: str | None = None
+
+    # Job Queue Settings
+    job_queue_name: str = "boards-jobs"
+    job_timeout: int = 3600  # 1 hour default timeout
+
+    # File Upload Settings
+    max_upload_size: int = 100 * 1024 * 1024  # 100MB
+    allowed_upload_extensions: list[str] = [
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".gif",
+        ".webp",  # Images
+        ".mp4",
+        ".mov",
+        ".avi",
+        ".webm",  # Videos
+        ".mp3",
+        ".wav",
+        ".ogg",
+        ".m4a",  # Audio
+        ".txt",
+        ".md",
+        ".json",  # Text
+    ]
+
+    class Config:
+        env_file = ".env"
+        env_prefix = "BOARDS_"
+        case_sensitive = False
+
+        # Allow extra fields for provider-specific configs
+        extra = "allow"
+
+
+# Global settings instance
+settings = Settings()
+
+
+def initialize_generator_api_keys() -> None:
+    """
+    Sync generator API keys from settings to os.environ.
+
+    This allows third-party packages (like replicate) that expect
+    environment variables to work correctly with our Pydantic settings.
+    """
+    for key, value in settings.generator_api_keys.items():
+        if value:  # Only set non-empty values
+            os.environ[key] = value
+
+
+# Helper functions
+def get_database_url(tenant_slug: str | None = None) -> str:
+    """Get database URL, optionally with tenant-specific schema."""
+    if settings.multi_tenant_mode and tenant_slug:
+        # In multi-tenant mode, could use schemas or separate databases
+        # For now, we'll use the same database with tenant isolation via queries
+        return settings.database_url
+    return settings.database_url

package/templates/api/src/boards/database/__init__.py

@@ -0,0 +1,7 @@
+"""
+Database module for Boards backend
+"""
+
+from .connection import get_engine, get_session, init_database
+
+__all__ = ["get_engine", "get_session", "init_database"]

package/templates/api/src/boards/database/cli.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+CLI entry point for Boards database migrations.
+"""
+
+import sys
+from pathlib import Path
+
+import click
+
+from alembic import command
+from alembic.config import Config
+from boards import __version__
+from boards.logging import configure_logging, get_logger
+
+logger = get_logger(__name__)
+
+
+def get_alembic_config() -> Config:
+    """Get Alembic configuration."""
+    # Find alembic.ini in the package directory
+    package_dir = Path(__file__).parent.parent.parent.parent
+    alembic_ini = package_dir / "alembic.ini"
+
+    if not alembic_ini.exists():
+        raise FileNotFoundError(f"alembic.ini not found at {alembic_ini}")
+
+    return Config(str(alembic_ini))
+
+
+@click.group()
+@click.option(
+    "--log-level",
+    default="info",
+    type=click.Choice(["debug", "info", "warning", "error"]),
+    help="Log level (default: info)",
+)
+@click.version_option(version=__version__, prog_name="boards-migrate")
+def main(log_level: str) -> None:
+    """Boards database migration management."""
+    configure_logging(debug=(log_level == "debug"))
+
+
+@main.command()
+@click.argument("revision", default="head")
+def upgrade(revision: str) -> None:
+    """Upgrade database to a revision (default: head)."""
+    try:
+        config = get_alembic_config()
+        logger.info("Upgrading database", revision=revision)
+        command.upgrade(config, revision)
+        logger.info("Database upgrade completed successfully")
+    except Exception as e:
+        logger.error("Database upgrade failed", error=str(e))
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("revision", default="-1")
+def downgrade(revision: str) -> None:
+    """Downgrade database to a revision (default: -1)."""
+    try:
+        config = get_alembic_config()
+        logger.info("Downgrading database", revision=revision)
+        command.downgrade(config, revision)
+        logger.info("Database downgrade completed successfully")
+    except Exception as e:
+        logger.error("Database downgrade failed", error=str(e))
+        sys.exit(1)
+
+
+@main.command()
+@click.option("-m", "--message", required=True, help="Revision message")
+@click.option("--autogenerate/--no-autogenerate", default=True, help="Auto-generate migration")
+def revision(message: str, autogenerate: bool) -> None:
+    """Create a new migration revision."""
+    try:
+        config = get_alembic_config()
+        logger.info("Creating new migration", message=message, autogenerate=autogenerate)
+        command.revision(config, message=message, autogenerate=autogenerate)
+        logger.info("Migration created successfully")
+    except Exception as e:
+        logger.error("Migration creation failed", error=str(e))
+        sys.exit(1)
+
+
+@main.command()
+def current() -> None:
+    """Show current database revision."""
+    try:
+        config = get_alembic_config()
+        command.current(config)
+    except Exception as e:
+        logger.error("Failed to get current revision", error=str(e))
+        sys.exit(1)
+
+
+@main.command()
+def history() -> None:
+    """Show migration history."""
+    try:
+        config = get_alembic_config()
+        command.history(config)
+    except Exception as e:
+        logger.error("Failed to get migration history", error=str(e))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()