@weirdfingers/baseboards 0.9.5 → 0.9.7

package/templates/api/src/boards/workers/context.py

@@ -1,348 +0,0 @@
-"""Execution context passed to generators for storage/DB/progress access."""
-
-from __future__ import annotations
-
-from uuid import UUID, uuid4
-
-from ..database.connection import get_async_session
-from ..generators import resolution
-from ..generators.artifacts import (
-    AudioArtifact,
-    ImageArtifact,
-    TextArtifact,
-    VideoArtifact,
-)
-from ..jobs import repository as jobs_repo
-from ..logging import get_logger
-from ..progress.models import ProgressUpdate
-from ..progress.publisher import ProgressPublisher
-from ..storage.base import StorageManager
-
-logger = get_logger(__name__)
-
-
-class GeneratorExecutionContext:
-    def __init__(
-        self,
-        generation_id: UUID,
-        publisher: ProgressPublisher,
-        storage_manager: StorageManager,
-        tenant_id: UUID,
-        board_id: UUID,
-        user_id: UUID,
-        generator_name: str,
-        artifact_type: str,
-        input_params: dict,
-    ) -> None:
-        self.generation_id = str(generation_id)
-        self.publisher = publisher
-        self.storage_manager = storage_manager
-        self.tenant_id = str(tenant_id)
-        self.board_id = str(board_id)
-        self.user_id = str(user_id)
-        self.generator_name = generator_name
-        self.artifact_type = artifact_type
-        self.input_params = input_params
-        self._batch_id: str | None = None
-        self._batch_generations: list[str] = []
-        logger.info(
-            "Created execution context",
-            generation_id=str(generation_id),
-            tenant_id=str(tenant_id),
-            board_id=str(board_id),
-        )
-
-    async def resolve_artifact(self, artifact) -> str:
-        """Resolve an artifact to a file path."""
-        logger.debug("Resolving artifact", generation_id=self.generation_id)
-        try:
-            result = await resolution.resolve_artifact(artifact)
-            logger.debug("Artifact resolved successfully", result=result)
-            return result
-        except Exception as e:
-            logger.error("Failed to resolve artifact", error=str(e))
-            raise
-
-    async def store_image_result(
-        self,
-        storage_url: str,
-        format: str,
-        width: int | None = None,
-        height: int | None = None,
-        output_index: int = 0,
-    ) -> ImageArtifact:
-        """Store image generation result.
-
-        Args:
-            storage_url: URL to download the image from
-            format: Image format (png, jpg, etc.)
-            width: Image width in pixels (optional)
-            height: Image height in pixels (optional)
-            output_index: Index of this output in a batch (0 for primary, 1+ for additional)
-
-        Returns:
-            ImageArtifact with the generation_id set appropriately
-        """
-        logger.debug(
-            "Storing image result",
-            generation_id=self.generation_id,
-            output_index=output_index,
-        )
-        try:
-            # Determine which generation_id to use
-            target_generation_id = await self._get_or_create_generation_for_output(output_index)
-
-            result = await resolution.store_image_result(
-                storage_manager=self.storage_manager,
-                generation_id=target_generation_id,
-                tenant_id=self.tenant_id,
-                board_id=self.board_id,
-                storage_url=storage_url,
-                format=format,
-                width=width,
-                height=height,
-            )
-            logger.info(
-                "Image result stored",
-                generation_id=target_generation_id,
-                output_index=output_index,
-            )
-            return result
-        except Exception as e:
-            logger.error("Failed to store image result", error=str(e))
-            raise
-
-    async def store_video_result(
-        self,
-        storage_url: str,
-        format: str,
-        width: int | None = None,
-        height: int | None = None,
-        duration: float | None = None,
-        fps: float | None = None,
-        output_index: int = 0,
-    ) -> VideoArtifact:
-        """Store video generation result.
-
-        Args:
-            storage_url: URL to download the video from
-            format: Video format (mp4, webm, etc.)
-            width: Video width in pixels (optional)
-            height: Video height in pixels (optional)
-            duration: Video duration in seconds (optional)
-            fps: Frames per second (optional)
-            output_index: Index of this output in a batch (0 for primary, 1+ for additional)
-
-        Returns:
-            VideoArtifact with the generation_id set appropriately
-        """
-        logger.debug(
-            "Storing video result",
-            generation_id=self.generation_id,
-            output_index=output_index,
-        )
-        try:
-            # Determine which generation_id to use
-            target_generation_id = await self._get_or_create_generation_for_output(output_index)
-
-            result = await resolution.store_video_result(
-                storage_manager=self.storage_manager,
-                generation_id=target_generation_id,
-                tenant_id=self.tenant_id,
-                board_id=self.board_id,
-                storage_url=storage_url,
-                format=format,
-                width=width,
-                height=height,
-                duration=duration,
-                fps=fps,
-            )
-            logger.info(
-                "Video result stored",
-                generation_id=target_generation_id,
-                output_index=output_index,
-            )
-            return result
-        except Exception as e:
-            logger.error("Failed to store video result", error=str(e))
-            raise
-
-    async def store_audio_result(
-        self,
-        storage_url: str,
-        format: str,
-        duration: float | None = None,
-        sample_rate: int | None = None,
-        channels: int | None = None,
-        output_index: int = 0,
-    ) -> AudioArtifact:
-        """Store audio generation result.
-
-        Args:
-            storage_url: URL to download the audio from
-            format: Audio format (mp3, wav, etc.)
-            duration: Audio duration in seconds (optional)
-            sample_rate: Sample rate in Hz (optional)
-            channels: Number of audio channels (optional)
-            output_index: Index of this output in a batch (0 for primary, 1+ for additional)
-
-        Returns:
-            AudioArtifact with the generation_id set appropriately
-        """
-        logger.debug(
-            "Storing audio result",
-            generation_id=self.generation_id,
-            output_index=output_index,
-        )
-        try:
-            # Determine which generation_id to use
-            target_generation_id = await self._get_or_create_generation_for_output(output_index)
-
-            result = await resolution.store_audio_result(
-                storage_manager=self.storage_manager,
-                generation_id=target_generation_id,
-                tenant_id=self.tenant_id,
-                board_id=self.board_id,
-                storage_url=storage_url,
-                format=format,
-                duration=duration,
-                sample_rate=sample_rate,
-                channels=channels,
-            )
-            logger.info(
-                "Audio result stored",
-                generation_id=target_generation_id,
-                output_index=output_index,
-            )
-            return result
-        except Exception as e:
-            logger.error("Failed to store audio result", error=str(e))
-            raise
-
-    async def store_text_result(
-        self,
-        content: str,
-        format: str,
-        output_index: int = 0,
-    ) -> TextArtifact:
-        """Store text generation result.
-
-        Args:
-            content: Text content to store
-            format: Text format (plain, markdown, html, etc.)
-            output_index: Index of this output in a batch (0 for primary, 1+ for additional)
-
-        Returns:
-            TextArtifact with the generation_id set appropriately
-        """
-        logger.debug(
-            "Storing text result",
-            generation_id=self.generation_id,
-            output_index=output_index,
-        )
-        try:
-            # Determine which generation_id to use
-            target_generation_id = await self._get_or_create_generation_for_output(output_index)
-
-            result = await resolution.store_text_result(
-                storage_manager=self.storage_manager,
-                generation_id=target_generation_id,
-                tenant_id=self.tenant_id,
-                board_id=self.board_id,
-                content=content,
-                format=format,
-            )
-            logger.info(
-                "Text result stored",
-                generation_id=target_generation_id,
-                output_index=output_index,
-            )
-            return result
-        except Exception as e:
-            logger.error("Failed to store text result", error=str(e))
-            raise
-
-    async def publish_progress(self, update: ProgressUpdate) -> None:
-        """Publish progress update for the generation."""
-        logger.debug(
-            "Publishing progress",
-            generation_id=self.generation_id,
-            status=update.status,
-            progress=update.progress,
-        )
-        try:
-            await self.publisher.publish_progress(self.generation_id, update)
-        except Exception as e:
-            logger.error(
-                "Failed to publish progress update - "
-                "generation will continue but progress may not be visible",
-                generation_id=self.generation_id,
-                status=update.status,
-                progress=update.progress,
-                error=str(e),
-                error_type=type(e).__name__,
-            )
-            # Don't raise here - progress updates are non-critical
-            # The generation should continue even if progress updates fail
-
-    async def set_external_job_id(self, external_id: str) -> None:
-        """Set the external job ID from the provider."""
-        logger.info(
-            "Setting external job ID",
-            external_job_id=external_id,
-            generation_id=self.generation_id,
-        )
-        async with get_async_session() as session:
-            await jobs_repo.set_external_job_id(session, self.generation_id, external_id)
-
-    async def _get_or_create_generation_for_output(self, output_index: int) -> str:
-        """Get or create a generation record for the given output index.
-
-        Args:
-            output_index: Index of the output (0 for primary, 1+ for batch outputs)
-
-        Returns:
-            generation_id to use for storing this output
-        """
-        # Index 0 is always the primary generation
-        if output_index == 0:
-            return self.generation_id
-
-        # For batch outputs, ensure we have a batch_id
-        if self._batch_id is None:
-            self._batch_id = str(uuid4())
-            logger.debug(
-                "Created batch_id for multi-output generation",
-                batch_id=self._batch_id,
-                primary_generation_id=self.generation_id,
-            )
-
-        # Check if we've already created a generation for this index
-        batch_index = output_index - 1  # Adjust since index 0 is primary
-        if batch_index < len(self._batch_generations):
-            return self._batch_generations[batch_index]
-
-        # Create new batch generation record
-        async with get_async_session() as session:
-            batch_gen_id = await jobs_repo.create_batch_generation(
-                session,
-                tenant_id=UUID(self.tenant_id),
-                board_id=UUID(self.board_id),
-                user_id=UUID(self.user_id),
-                generator_name=self.generator_name,
-                artifact_type=self.artifact_type,
-                input_params=self.input_params,
-                batch_id=self._batch_id,
-                batch_index=output_index,
-            )
-            await session.commit()
-
-        self._batch_generations.append(batch_gen_id)
-        logger.info(
-            "Created batch generation record",
-            batch_generation_id=batch_gen_id,
-            primary_generation_id=self.generation_id,
-            batch_id=self._batch_id,
-            batch_index=output_index,
-        )
-        return batch_gen_id

package/templates/api/src/boards/workers/middleware.py

@@ -1,58 +0,0 @@
-"""Dramatiq middleware for worker process initialization.
-
-This module provides custom middleware for managing worker lifecycle,
-particularly for loading generators during worker startup.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from dramatiq.middleware import Middleware
-
-from ..config import initialize_generator_api_keys
-from ..generators.loader import load_generators_from_config
-from ..generators.registry import registry as generator_registry
-from ..logging import get_logger
-
-if TYPE_CHECKING:
-    from dramatiq import Broker, Worker
-
-logger = get_logger(__name__)
-
-
-class GeneratorLoaderMiddleware(Middleware):
-    """Middleware to load generators when worker process starts.
-
-    This ensures that generators are registered in each worker process's
-    registry before any jobs are processed. Since Dramatiq uses multiprocessing,
-    each worker process gets its own copy of the registry, so initialization
-    must happen in each process.
-
-    The before_worker_boot hook runs once per worker process at startup,
-    before any actors are executed. Worker processes are long-running and
-    reused across many jobs, so this initialization overhead happens only
-    once per worker lifetime.
-    """
-
-    def before_worker_boot(self, broker: Broker, worker: Worker) -> None:
-        """Load generators when worker process starts.
-
-        Args:
-            broker: The Dramatiq broker instance
-            worker: The worker process instance
-        """
-        logger.info("Loading generators in worker process", worker_id=id(worker))
-
-        # Initialize generator API keys before loading generators
-        initialize_generator_api_keys()
-        logger.info("Generator API keys initialized in worker process")
-
-        load_generators_from_config()
-
-        logger.info(
-            "Generators loaded in worker process",
-            worker_id=id(worker),
-            generator_count=len(generator_registry.list_names()),
-            generators=generator_registry.list_names(),
-        )

package/templates/compose.web.yaml

@@ -1,35 +0,0 @@
-# Docker Compose Overlay - Web Service
-#
-# This overlay adds the web (frontend) service as a production-built container.
-# Use this overlay when you want to run the full stack including the frontend.
-#
-# Usage:
-#   docker compose -f compose.yaml up -d                     # Backend only (no web)
-#   docker compose -f compose.yaml -f compose.web.yaml up -d # Full stack with web
-#
-# The web service runs a production build (no hot-reload, no volume mounts).
-# For app development mode where you run the frontend locally, skip this overlay.
-
-services:
-  web:
-    build:
-      context: ./web
-      dockerfile: ../Dockerfile.web
-      args:
-        NEXT_PUBLIC_API_URL: ${NEXT_PUBLIC_API_URL:-http://localhost:8800}
-        NEXT_PUBLIC_GRAPHQL_URL: ${NEXT_PUBLIC_GRAPHQL_URL:-http://localhost:8800/graphql}
-    env_file: web/.env
-    environment:
-      - INTERNAL_API_URL=http://api:8800
-    depends_on:
-      api:
-        condition: service_healthy
-    ports:
-      - "${WEB_PORT:-3300}:3000"
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:3000/"]
-      interval: 5s
-      timeout: 3s
-      retries: 50
-    networks:
-      - internal

package/templates/compose.yaml

@@ -1,116 +0,0 @@
-# Docker Compose Configuration for Baseboards
-name: ${PROJECT_NAME:-baseboards}
-
-services:
-  db:
-    image: postgres:16
-    env_file: docker/.env
-    volumes:
-      - db-data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER"]
-      interval: 5s
-      timeout: 5s
-      retries: 20
-    networks:
-      - internal
-
-  cache:
-    image: redis:7
-    command: ["redis-server", "--appendonly", "yes"]
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 5s
-      timeout: 3s
-      retries: 20
-    networks:
-      - internal
-
-  api:
-    # Pre-built backend image from GitHub Container Registry
-    # Override version with BACKEND_VERSION in docker/.env (defaults to latest)
-    image: ghcr.io/weirdfingers/boards-backend:${BACKEND_VERSION:-latest}
-    command: ["uvicorn", "boards.api.app:app", "--host", "0.0.0.0", "--port", "8800"]
-    env_file:
-      - docker/.env
-      - api/.env
-    environment:
-      # Enable loading custom generators and plugins from /app/extensions
-      # Include /app/src for the boards module (from Docker image)
-      - PYTHONPATH=/app/src:/app/extensions
-      # Explicit paths to configuration files
-      - BOARDS_GENERATORS_CONFIG_PATH=/app/config/generators.yaml
-      - BOARDS_STORAGE_CONFIG_PATH=/app/config/storage_config.yaml
-      # Ensure logs are visible in real-time (no buffering)
-      - PYTHONUNBUFFERED=1
-    volumes:
-      # Configuration files (read-only)
-      - ./config:/app/config:ro
-      # Generated media persistence (read-write)
-      - ./data/storage:/app/data/storage
-      # Custom generators and plugins (read-only)
-      - ./extensions:/app/extensions:ro
-    depends_on:
-      db:
-        condition: service_healthy
-      cache:
-        condition: service_healthy
-    ports:
-      - "${API_PORT:-8800}:8800"
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:8800/health"]
-      interval: 30s
-      timeout: 3s
-      retries: 50
-    networks:
-      - internal
-
-  worker:
-    # Pre-built backend image from GitHub Container Registry
-    # Override version with BACKEND_VERSION in docker/.env (defaults to latest)
-    image: ghcr.io/weirdfingers/boards-backend:${BACKEND_VERSION:-latest}
-    command:
-      [
-        "boards-worker",
-        "--log-level",
-        "debug",
-        "--processes",
-        "1",
-        "--threads",
-        "1",
-      ]
-    env_file:
-      - docker/.env
-      - api/.env
-    environment:
-      # Enable loading custom generators and plugins from /app/extensions
-      # Include /app/src for the boards module (from Docker image)
-      - PYTHONPATH=/app/src:/app/extensions
-      # Explicit paths to configuration files
-      - BOARDS_GENERATORS_CONFIG_PATH=/app/config/generators.yaml
-      - BOARDS_STORAGE_CONFIG_PATH=/app/config/storage_config.yaml
-      # Internal API URL for worker communication
-      - BOARDS_INTERNAL_API_URL=http://api:8800
-      # Ensure logs are visible in real-time (no buffering)
-      - PYTHONUNBUFFERED=1
-    volumes:
-      # Configuration files (read-only)
-      - ./config:/app/config:ro
-      # Generated media persistence (read-write)
-      - ./data/storage:/app/data/storage
-      # Custom generators and plugins (read-only)
-      - ./extensions:/app/extensions:ro
-    depends_on:
-      db:
-        condition: service_healthy
-      cache:
-        condition: service_healthy
-    networks:
-      - internal
-
-networks:
-  internal:
-    driver: bridge
-
-volumes:
-  db-data:

package/templates/docker/env.example

@@ -1,23 +0,0 @@
-# Docker Compose Environment Variables
-# Generated by CLI - DO NOT EDIT MANUALLY
-
-# Project configuration
-PROJECT_NAME=baseboards
-
-# Service ports
-WEB_PORT=3300
-API_PORT=8800
-
-# PostgreSQL configuration
-POSTGRES_USER=baseboards
-POSTGRES_PASSWORD=REPLACE_WITH_GENERATED_PASSWORD
-POSTGRES_DB=baseboards
-
-# Database URL (for API container)
-BOARDS_DATABASE_URL=postgresql://baseboards:REPLACE_WITH_GENERATED_PASSWORD@db:5432/baseboards
-
-# Redis URL (for API container)
-BOARDS_REDIS_URL=redis://cache:6379/0
-
-# Image version (matches CLI version)
-VERSION=latest

package/templates/web/.env.example

@@ -1,28 +0,0 @@
-# Frontend Environment Variables
-
-# API Configuration
-NEXT_PUBLIC_API_URL=http://localhost:8800
-NEXT_PUBLIC_GRAPHQL_URL=http://localhost:8800/graphql
-
-# Internal API URL for Docker
-# When running in Docker, this URL is used for server-side requests (like image optimization)
-# to access the API via the internal Docker network instead of localhost
-INTERNAL_API_URL=http://api:8800
-
-# Auth Provider
-# For local development, 'none' allows unauthenticated access
-NEXT_PUBLIC_AUTH_PROVIDER=none
-
-# Clerk
-# NEXT_PUBLIC_AUTH_PROVIDER=clerk
-# NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_test_...
-
-# Supabase
-# NEXT_PUBLIC_AUTH_PROVIDER=supabase
-# NEXT_PUBLIC_SUPABASE_URL=https://xxx.supabase.co
-# NEXT_PUBLIC_SUPABASE_ANON_KEY=...
-
-# Auth0
-# NEXT_PUBLIC_AUTH_PROVIDER=auth0
-# NEXT_PUBLIC_AUTH0_DOMAIN=...
-# NEXT_PUBLIC_AUTH0_CLIENT_ID=...

package/templates/web/Dockerfile

@@ -1,51 +0,0 @@
-FROM node:20-alpine AS base
-
-# Install dependencies only when needed
-FROM base AS deps
-RUN apk add --no-cache libc6-compat
-WORKDIR /app
-
-# Copy package files
-COPY package.json package-lock.json* pnpm-lock.yaml* ./
-RUN corepack enable pnpm && pnpm install
-
-# Rebuild the source code only when needed
-FROM base AS builder
-WORKDIR /app
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-
-# Accept build args for Next.js public env vars
-ARG NEXT_PUBLIC_API_URL
-ARG NEXT_PUBLIC_GRAPHQL_URL
-ENV NEXT_PUBLIC_API_URL=${NEXT_PUBLIC_API_URL}
-ENV NEXT_PUBLIC_GRAPHQL_URL=${NEXT_PUBLIC_GRAPHQL_URL}
-
-RUN corepack enable pnpm && pnpm run build
-
-# Production image, copy all the files and run next
-FROM base AS runner
-WORKDIR /app
-
-ENV NODE_ENV=production
-
-RUN addgroup --system --gid 1001 nodejs
-RUN adduser --system --uid 1001 nextjs
-
-# Enable pnpm for dev mode (must be done as root before USER switch)
-RUN corepack enable pnpm
-
-# Automatically leverage output traces to reduce image size
-# https://nextjs.org/docs/advanced-features/output-file-tracing
-COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
-COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
-COPY --from=builder --chown=nextjs:nodejs /app/public ./public
-
-USER nextjs
-
-EXPOSE 3000
-
-ENV PORT=3000
-ENV HOSTNAME="0.0.0.0"
-
-CMD ["node", "server.js"]

package/templates/web/components.json

@@ -1,22 +0,0 @@
-{
-  "$schema": "https://ui.shadcn.com/schema.json",
-  "style": "new-york",
-  "rsc": true,
-  "tsx": true,
-  "tailwind": {
-    "config": "",
-    "css": "src/app/globals.css",
-    "baseColor": "neutral",
-    "cssVariables": true,
-    "prefix": ""
-  },
-  "iconLibrary": "lucide",
-  "aliases": {
-    "components": "@/components",
-    "utils": "@/lib/utils",
-    "ui": "@/components/ui",
-    "lib": "@/lib",
-    "hooks": "@/hooks"
-  },
-  "registries": {}
-}