Initial deployment - Content Engine

Dockerfile

@@ -0,0 +1,40 @@
+# Hugging Face Spaces Dockerfile for Content Engine
+FROM python:3.11-slim
+
+# Create user with UID 1000 (HF Spaces requirement)
+RUN useradd -m -u 1000 user
+
+# Install system dependencies as root
+RUN apt-get update && apt-get install -y \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Switch to user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copy requirements first for caching
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy application code
+COPY --chown=user ./src ./src
+COPY --chown=user ./config ./config
+
+# Create directories for data persistence
+RUN mkdir -p /app/data/output /app/data/output/videos /app/data/db /app/data/uploads /app/data/loras /app/data/models /app/data/training
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH=/app/src
+ENV HF_SPACES=1
+ENV OUTPUT_DIR=/app/data/output
+ENV DATA_DIR=/app/data
+ENV DB_PATH=/app/data/db/content_engine.db
+ENV UPLOAD_DIR=/app/data/uploads
+
+# HF Spaces requires port 7860
+EXPOSE 7860
+CMD ["uvicorn", "content_engine.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,41 @@
----
-title: Content Engine
-emoji: 🏢
-colorFrom: red
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Content Engine - AI Image & Video Generation
+
+A web-based content generation platform using RunPod for GPU-powered image and video generation.
+
+## Features
+
+- **Image Generation**: FLUX.2 and WAN 2.2 models via RunPod GPU
+- **Video Generation**: WAN 2.2 Image-to-Video
+- **LoRA Training**: Train custom character models
+- **Gallery**: Browse, download, and manage generated content
+- **Templates**: Pre-configured prompts for consistent results
+
+## Setup
+
+This Space requires RunPod API credentials to function:
+
+1. Get your RunPod API key from https://www.runpod.io/console/user/settings
+2. Add it as a Space Secret: `RUNPOD_API_KEY`
+
+Optional:
+- `WAVESPEED_API_KEY`: For WaveSpeed cloud generation (alternative backend)
+
+## Usage
+
+1. Go to **Status** page and click **Start Pod** to boot a GPU
+2. Wait ~2-3 minutes for the pod to be ready
+3. Use **Generate** page to create images/videos
+4. **Stop Pod** when done to save costs
+
+## Cost
+
+- RunPod GPU (RTX 4090): ~$0.44/hour while running
+- No cost when pod is stopped
+- Images/videos stored on Hugging Face (free)
+
+## Tech Stack
+
+- FastAPI backend
+- RunPod for GPU compute
+- SQLite for metadata
+- Pure HTML/CSS/JS frontend

config/characters/example_character.yaml

@@ -0,0 +1,29 @@
+# Example character profile — replace with your trained LoRA details
+#
+# To use this:
+# 1. Train a LoRA using Kohya_ss with ~20-50 reference images
+# 2. Place the .safetensors file in D:\ComfyUI\Models\Lora\
+# 3. Update the fields below with your character's details
+# 4. Rename this file to your character's name (e.g., alice.yaml)
+
+id: example
+name: "Example Character"
+trigger_word: "examplechar"          # The trigger word used during LoRA training
+lora_filename: "example_v1.safetensors"  # Filename in D:\ComfyUI\Models\Lora\
+lora_strength: 0.85                  # 0.6-0.9 typically works best
+
+# Optional: override default checkpoint for this character
+# default_checkpoint: "realisticVisionV51_v51VAE.safetensors"
+
+# Optional: additional style LoRAs to stack
+style_loras: []
+  # - name: "glamour_style_v1.safetensors"
+  #   strength_model: 0.5
+  #   strength_clip: 0.5
+
+description: "Example character for testing the pipeline"
+
+physical_traits:
+  hair: "brown, shoulder length"
+  eyes: "blue"
+  build: "average"

config/models.yaml

@@ -0,0 +1,95 @@
+# Training Model Registry
+# Defines base models available for LoRA training with their optimal parameters
+
+training_models:
+  # FLUX - Best for photorealistic images (recommended for realistic person)
+  flux2_dev:
+    name: "FLUX.2 Dev (Recommended)"
+    description: "Latest FLUX model, 32B params, best quality for realistic person. Also supports multi-reference without training."
+    hf_repo: "black-forest-labs/FLUX.2-dev"
+    hf_filename: "flux.2-dev.safetensors"
+    model_type: "flux"
+    resolution: 1024
+    learning_rate: 1e-3
+    text_encoder_lr: 1e-4
+    network_rank: 48
+    network_alpha: 24
+    clip_skip: 1
+    optimizer: "AdamW8bit"
+    lr_scheduler: "cosine"
+    min_snr_gamma: 5
+    max_train_steps: 1200
+    fp8_base: true
+    use_case: "images"
+    vram_required_gb: 24
+    recommended_images: "15-30 high quality photos with detailed captions"
+    training_script: "flux_train_network.py"
+
+  flux1_dev:
+    name: "FLUX.1 Dev"
+    description: "Previous gen FLUX, still excellent for realistic person LoRAs"
+    hf_repo: "black-forest-labs/FLUX.1-dev"
+    hf_filename: "flux1-dev.safetensors"
+    model_type: "flux"
+    resolution: 768
+    learning_rate: 4e-4
+    text_encoder_lr: 4e-5
+    network_rank: 32
+    network_alpha: 16
+    clip_skip: 1
+    optimizer: "AdamW8bit"
+    lr_scheduler: "cosine"
+    min_snr_gamma: 5
+    max_train_steps: 1500
+    use_case: "images"
+    vram_required_gb: 24
+    recommended_images: "15-30 high quality photos"
+    training_script: "flux_train_network.py"
+
+  # SD 1.5 Realistic Vision - Good balance of quality and speed
+  sd15_realistic:
+    name: "Realistic Vision V5.1"
+    description: "SD 1.5 based, great for realistic humans, faster training"
+    hf_repo: "SG161222/Realistic_Vision_V5.1_noVAE"
+    hf_filename: "Realistic_Vision_V5.1_fp16-no-ema.safetensors"
+    model_type: "sd15"
+    resolution: 512
+    learning_rate: 1e-4
+    network_rank: 32
+    network_alpha: 16
+    clip_skip: 1
+    optimizer: "AdamW8bit"
+    use_case: "images"
+    vram_required_gb: 8
+    recommended_images: "15-30 photos"
+
+  # SDXL - Higher quality than SD 1.5, but more VRAM
+  sdxl_base:
+    name: "SDXL Base 1.0"
+    description: "Higher resolution and quality than SD 1.5"
+    hf_repo: "stabilityai/stable-diffusion-xl-base-1.0"
+    hf_filename: "sd_xl_base_1.0.safetensors"
+    model_type: "sdxl"
+    resolution: 1024
+    learning_rate: 1e-4
+    network_rank: 32
+    network_alpha: 16
+    clip_skip: 2
+    optimizer: "AdamW8bit"
+    use_case: "images"
+    vram_required_gb: 12
+    recommended_images: "20-40 photos"
+
+# Video generation models (for img2video, not training)
+video_models:
+  wan22_i2v:
+    name: "WAN 2.2 Image-to-Video"
+    description: "Converts images to videos, use with your trained LoRA images"
+    hf_repo: "Wan-AI/Wan2.2-I2V-A14B"
+    model_type: "wan22"
+    use_case: "img2video"
+    vram_required_gb: 24
+    resolution: "480p/720p"
+
+# Default model for training
+default_training_model: "flux2_dev"

config/settings.yaml

@@ -0,0 +1,47 @@
+# Content Engine Configuration
+
+comfyui:
+  url: "http://127.0.0.1:8188"
+  # Maximum jobs to queue locally before routing to cloud
+  max_local_queue_depth: 3
+  # Minimum free VRAM (GB) required to accept a local job
+  min_vram_gb: 2.0
+
+paths:
+  output_dir: "D:/AI automation/output"
+  data_dir: "D:/AI automation/data"
+  # ComfyUI model paths (from extra_model_paths.yaml)
+  lora_dir: "D:/ComfyUI/Models/Lora"
+  checkpoint_dir: "D:/ComfyUI/Models/StableDiffusion"
+
+database:
+  # SQLite for v1, switch to postgresql:// for v2
+  url: "sqlite+aiosqlite:///D:/AI automation/data/catalog.db"
+  jobs_url: "sqlite+aiosqlite:///D:/AI automation/data/jobs.db"
+
+generation:
+  # Default generation parameters
+  default_checkpoint: "realisticVisionV51_v51VAE.safetensors"
+  default_steps: 28
+  default_cfg: 7.0
+  default_sampler: "dpmpp_2m"
+  default_scheduler: "karras"
+  default_width: 832
+  default_height: 1216
+
+scheduling:
+  # Posts per day per character
+  posts_per_day: 3
+  # Peak posting hours (UTC)
+  peak_hours: [10, 14, 20]
+  # SFW to NSFW ratio for scheduling
+  sfw_ratio: 0.4
+
+cloud_providers: []
+  # Uncomment and configure when ready (Phase 4)
+  # - name: replicate
+  #   api_key: "${REPLICATE_API_KEY}"
+  #   priority: 1
+  # - name: runpod
+  #   api_key: "${RUNPOD_API_KEY}"
+  #   priority: 2

config/templates/prompts/artistic_nude.yaml

@@ -0,0 +1,100 @@
+id: artistic_nude
+name: "Artistic Nude"
+category: artistic
+rating: nsfw
+base_model: realistic_vision
+
+loras:
+  - name: "{{character_lora}}"
+    strength_model: 0.85
+    strength_clip: 0.85
+
+positive_prompt: >
+  {{character_trigger}}, {{pose}}, nude,
+  {{emotion}} expression, {{camera_angle}},
+  {{lighting}}, {{scene}},
+  masterpiece, best quality, photorealistic, 8k uhd,
+  detailed skin texture, fine art photography,
+  artistic composition, tasteful, elegant
+
+negative_prompt: >
+  worst quality, low quality, blurry, deformed,
+  bad anatomy, bad hands, extra fingers,
+  watermark, text, signature, cartoon, anime,
+  unrealistic proportions, ugly
+
+sampler:
+  steps: 30
+  cfg: 7.5
+  sampler_name: dpmpp_2m
+  scheduler: karras
+  width: 832
+  height: 1216
+
+variables:
+  character_trigger:
+    type: string
+    required: true
+    description: "Character trigger word from LoRA training"
+  character_lora:
+    type: string
+    required: true
+    description: "Character LoRA filename"
+  pose:
+    type: choice
+    options:
+      - reclining
+      - standing profile
+      - seated with crossed legs
+      - back view
+      - curled up
+      - stretching
+      - lying on stomach
+      - kneeling
+  emotion:
+    type: choice
+    options:
+      - serene
+      - contemplative
+      - confident
+      - vulnerable
+      - sensual
+      - mysterious
+      - peaceful
+  camera_angle:
+    type: choice
+    options:
+      - eye level
+      - above looking down
+      - low angle
+      - side profile
+      - three quarter
+      - from behind
+  lighting:
+    type: choice
+    options:
+      - chiaroscuro
+      - soft diffused
+      - rim lighting
+      - golden hour
+      - dramatic single source
+      - natural daylight
+      - moody low key
+  scene:
+    type: choice
+    options:
+      - minimalist studio
+      - natural landscape
+      - classical interior
+      - fabric drapes
+      - water reflection
+      - garden
+      - abstract background
+
+motion:
+  enabled: false
+  type: loop
+  intensity: 0.3
+  motion_keywords:
+    - "slow breathing"
+    - "gentle wind"

config/templates/prompts/boudoir_intimate.yaml

@@ -0,0 +1,112 @@
+id: boudoir_intimate
+name: "Boudoir Intimate"
+category: boudoir
+rating: nsfw
+base_model: realistic_vision
+
+loras:
+  - name: "{{character_lora}}"
+    strength_model: 0.85
+    strength_clip: 0.85
+
+positive_prompt: >
+  {{character_trigger}}, {{pose}}, {{outfit}},
+  {{emotion}} expression, {{camera_angle}},
+  {{lighting}}, {{scene}},
+  masterpiece, best quality, photorealistic, 8k uhd,
+  detailed skin texture, professional boudoir photography,
+  intimate atmosphere, sensual, alluring
+
+negative_prompt: >
+  worst quality, low quality, blurry, deformed,
+  bad anatomy, bad hands, extra fingers,
+  watermark, text, signature, cartoon, anime,
+  unrealistic proportions
+
+sampler:
+  steps: 30
+  cfg: 7.0
+  sampler_name: dpmpp_2m
+  scheduler: karras
+  width: 832
+  height: 1216
+
+variables:
+  character_trigger:
+    type: string
+    required: true
+    description: "Character trigger word from LoRA training"
+  character_lora:
+    type: string
+    required: true
+    description: "Character LoRA filename"
+  pose:
+    type: choice
+    options:
+      - lying on bed
+      - sitting on edge of bed
+      - standing by window
+      - kneeling
+      - reclining on couch
+      - looking over shoulder
+      - stretching
+      - leaning forward
+  outfit:
+    type: choice
+    options:
+      - lingerie
+      - silk robe
+      - lace bodysuit
+      - sheer nightgown
+      - corset
+      - bikini
+      - oversized shirt
+      - towel
+  emotion:
+    type: choice
+    options:
+      - seductive
+      - playful
+      - confident
+      - dreamy
+      - mysterious
+      - inviting
+      - coy
+  camera_angle:
+    type: choice
+    options:
+      - eye level
+      - low angle
+      - high angle looking down
+      - close-up
+      - three quarter view
+      - from behind
+  lighting:
+    type: choice
+    options:
+      - warm candlelight
+      - soft window light
+      - golden hour
+      - dim ambient light
+      - neon accent lighting
+      - dramatic shadows
+      - backlit silhouette
+  scene:
+    type: choice
+    options:
+      - luxury bedroom
+      - hotel room
+      - bathtub
+      - balcony at dusk
+      - silk sheets
+      - vanity mirror
+      - penthouse suite
+
+motion:
+  enabled: false
+  type: loop
+  intensity: 0.5
+  motion_keywords:
+    - "slow breathing"
+    - "gentle movement"
+    - "hair falling"

config/templates/prompts/lifestyle_casual.yaml

@@ -0,0 +1,88 @@
+id: lifestyle_casual
+name: "Casual Lifestyle"
+category: lifestyle
+rating: sfw
+base_model: realistic_vision
+
+loras:
+  - name: "{{character_lora}}"
+    strength_model: 0.85
+    strength_clip: 0.85
+
+positive_prompt: >
+  {{character_trigger}}, casual lifestyle photo,
+  {{activity}}, {{outfit}}, {{emotion}} expression,
+  {{camera_angle}}, {{lighting}}, {{scene}},
+  masterpiece, best quality, photorealistic,
+  candid photography style, natural look
+
+negative_prompt: >
+  worst quality, low quality, blurry, deformed,
+  bad anatomy, bad hands, extra fingers,
+  watermark, text, signature, overly posed
+
+sampler:
+  steps: 25
+  cfg: 6.5
+  sampler_name: dpmpp_2m
+  scheduler: karras
+  width: 1024
+  height: 1024
+
+variables:
+  character_trigger:
+    type: string
+    required: true
+  character_lora:
+    type: string
+    required: true
+  activity:
+    type: choice
+    options:
+      - reading a book
+      - drinking coffee
+      - walking in park
+      - stretching
+      - cooking
+      - using laptop
+      - taking selfie
+  outfit:
+    type: choice
+    options:
+      - oversized sweater
+      - yoga pants and tank top
+      - summer dress
+      - jeans and t-shirt
+      - pajamas
+      - workout clothes
+  emotion:
+    type: choice
+    options:
+      - relaxed
+      - happy
+      - focused
+      - dreamy
+      - cheerful
+  camera_angle:
+    type: choice
+    options:
+      - eye level
+      - slightly above
+      - candid angle
+      - over the shoulder
+  lighting:
+    type: choice
+    options:
+      - morning light
+      - afternoon sun
+      - warm indoor lighting
+      - window light
+  scene:
+    type: choice
+    options:
+      - cozy bedroom
+      - modern kitchen
+      - sunny balcony
+      - coffee shop
+      - living room with plants
+      - yoga studio

config/templates/prompts/portrait_glamour.yaml

@@ -0,0 +1,108 @@
+id: portrait_glamour
+name: "Glamour Portrait"
+category: portrait
+rating: sfw
+base_model: realistic_vision
+
+loras:
+  - name: "{{character_lora}}"
+    strength_model: 0.85
+    strength_clip: 0.85
+
+positive_prompt: >
+  {{character_trigger}}, {{pose}}, {{outfit}},
+  {{emotion}} expression, {{camera_angle}},
+  {{lighting}}, {{scene}},
+  masterpiece, best quality, photorealistic, 8k uhd,
+  detailed skin texture, professional photography
+
+negative_prompt: >
+  worst quality, low quality, blurry, deformed,
+  bad anatomy, bad hands, extra fingers,
+  watermark, text, signature
+
+sampler:
+  steps: 28
+  cfg: 7.0
+  sampler_name: dpmpp_2m
+  scheduler: karras
+  width: 832
+  height: 1216
+
+variables:
+  character_trigger:
+    type: string
+    required: true
+    description: "Character trigger word from LoRA training"
+  character_lora:
+    type: string
+    required: true
+    description: "Character LoRA filename"
+  pose:
+    type: choice
+    options:
+      - standing
+      - sitting
+      - leaning against wall
+      - walking
+      - looking over shoulder
+      - hands on hips
+      - arms crossed
+  outfit:
+    type: choice
+    options:
+      - casual dress
+      - evening gown
+      - business suit
+      - athletic wear
+      - sundress
+      - leather jacket
+      - crop top and jeans
+  emotion:
+    type: choice
+    options:
+      - confident
+      - playful
+      - serious
+      - mysterious
+      - warm smile
+      - contemplative
+      - laughing
+  camera_angle:
+    type: choice
+    options:
+      - front view
+      - three quarter view
+      - side profile
+      - low angle
+      - high angle
+      - close-up portrait
+  lighting:
+    type: choice
+    options:
+      - natural light
+      - golden hour
+      - studio lighting
+      - rim lighting
+      - neon lighting
+      - dramatic shadows
+      - soft diffused light
+  scene:
+    type: choice
+    options:
+      - urban rooftop
+      - luxury interior
+      - garden
+      - beach at sunset
+      - studio backdrop
+      - cozy cafe
+      - city street at night
+
+motion:
+  enabled: false
+  type: loop
+  intensity: 0.7
+  motion_keywords:
+    - "gentle swaying"
+    - "hair flowing in wind"
+    - "slow breathing"

config/templates/workflows/sd15_base_nsfw.json

@@ -0,0 +1,59 @@
+{
+    "1": {
+        "class_type": "CheckpointLoaderSimple",
+        "inputs": {
+            "ckpt_name": "realisticVisionV51_v51VAE.safetensors"
+        }
+    },
+    "2": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "clip": ["1", 1],
+            "text": ""
+        }
+    },
+    "3": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "clip": ["1", 1],
+            "text": "worst quality, low quality, blurry, deformed, bad anatomy, bad hands, extra fingers, watermark, text, signature, censored"
+        }
+    },
+    "4": {
+        "class_type": "EmptyLatentImage",
+        "inputs": {
+            "width": 832,
+            "height": 1216,
+            "batch_size": 1
+        }
+    },
+    "5": {
+        "class_type": "KSampler",
+        "inputs": {
+            "model": ["1", 0],
+            "positive": ["2", 0],
+            "negative": ["3", 0],
+            "latent_image": ["4", 0],
+            "seed": 0,
+            "steps": 28,
+            "cfg": 7.0,
+            "sampler_name": "dpmpp_2m",
+            "scheduler": "karras",
+            "denoise": 1.0
+        }
+    },
+    "6": {
+        "class_type": "VAEDecode",
+        "inputs": {
+            "samples": ["5", 0],
+            "vae": ["1", 2]
+        }
+    },
+    "7": {
+        "class_type": "SaveImage",
+        "inputs": {
+            "images": ["6", 0],
+            "filename_prefix": "content_engine"
+        }
+    }
+}

config/templates/workflows/sd15_base_sfw.json

@@ -0,0 +1,59 @@
+{
+    "1": {
+        "class_type": "CheckpointLoaderSimple",
+        "inputs": {
+            "ckpt_name": "realisticVisionV51_v51VAE.safetensors"
+        }
+    },
+    "2": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "clip": ["1", 1],
+            "text": ""
+        }
+    },
+    "3": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "clip": ["1", 1],
+            "text": "worst quality, low quality, blurry, deformed, bad anatomy, bad hands, extra fingers, watermark, text, signature"
+        }
+    },
+    "4": {
+        "class_type": "EmptyLatentImage",
+        "inputs": {
+            "width": 832,
+            "height": 1216,
+            "batch_size": 1
+        }
+    },
+    "5": {
+        "class_type": "KSampler",
+        "inputs": {
+            "model": ["1", 0],
+            "positive": ["2", 0],
+            "negative": ["3", 0],
+            "latent_image": ["4", 0],
+            "seed": 0,
+            "steps": 28,
+            "cfg": 7.0,
+            "sampler_name": "dpmpp_2m",
+            "scheduler": "karras",
+            "denoise": 1.0
+        }
+    },
+    "6": {
+        "class_type": "VAEDecode",
+        "inputs": {
+            "samples": ["5", 0],
+            "vae": ["1", 2]
+        }
+    },
+    "7": {
+        "class_type": "SaveImage",
+        "inputs": {
+            "images": ["6", 0],
+            "filename_prefix": "content_engine"
+        }
+    }
+}

config/templates/workflows/sd15_img2img_nsfw.json

@@ -0,0 +1,64 @@
+{
+    "1": {
+        "class_type": "CheckpointLoaderSimple",
+        "inputs": {
+            "ckpt_name": "realisticVisionV51_v51VAE.safetensors"
+        }
+    },
+    "2": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "clip": ["1", 1],
+            "text": ""
+        }
+    },
+    "3": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "clip": ["1", 1],
+            "text": "worst quality, low quality, blurry, deformed, bad anatomy, bad hands, extra fingers, watermark, text, signature"
+        }
+    },
+    "8": {
+        "class_type": "LoadImage",
+        "inputs": {
+            "image": "input_image.png"
+        }
+    },
+    "9": {
+        "class_type": "VAEEncode",
+        "inputs": {
+            "pixels": ["8", 0],
+            "vae": ["1", 2]
+        }
+    },
+    "5": {
+        "class_type": "KSampler",
+        "inputs": {
+            "model": ["1", 0],
+            "positive": ["2", 0],
+            "negative": ["3", 0],
+            "latent_image": ["9", 0],
+            "seed": 0,
+            "steps": 28,
+            "cfg": 7.0,
+            "sampler_name": "dpmpp_2m",
+            "scheduler": "karras",
+            "denoise": 0.65
+        }
+    },
+    "6": {
+        "class_type": "VAEDecode",
+        "inputs": {
+            "samples": ["5", 0],
+            "vae": ["1", 2]
+        }
+    },
+    "7": {
+        "class_type": "SaveImage",
+        "inputs": {
+            "images": ["6", 0],
+            "filename_prefix": "content_engine_img2img"
+        }
+    }
+}

config/templates/workflows/sd15_img2img_sfw.json

@@ -0,0 +1,64 @@
+{
+    "1": {
+        "class_type": "CheckpointLoaderSimple",
+        "inputs": {
+            "ckpt_name": "realisticVisionV51_v51VAE.safetensors"
+        }
+    },
+    "2": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "clip": ["1", 1],
+            "text": ""
+        }
+    },
+    "3": {
+        "class_type": "CLIPTextEncode",
+        "inputs": {
+            "clip": ["1", 1],
+            "text": "worst quality, low quality, blurry, deformed, bad anatomy, bad hands, extra fingers, watermark, text, signature"
+        }
+    },
+    "8": {
+        "class_type": "LoadImage",
+        "inputs": {
+            "image": "input_image.png"
+        }
+    },
+    "9": {
+        "class_type": "VAEEncode",
+        "inputs": {
+            "pixels": ["8", 0],
+            "vae": ["1", 2]
+        }
+    },
+    "5": {
+        "class_type": "KSampler",
+        "inputs": {
+            "model": ["1", 0],
+            "positive": ["2", 0],
+            "negative": ["3", 0],
+            "latent_image": ["9", 0],
+            "seed": 0,
+            "steps": 28,
+            "cfg": 7.0,
+            "sampler_name": "dpmpp_2m",
+            "scheduler": "karras",
+            "denoise": 0.65
+        }
+    },
+    "6": {
+        "class_type": "VAEDecode",
+        "inputs": {
+            "samples": ["5", 0],
+            "vae": ["1", 2]
+        }
+    },
+    "7": {
+        "class_type": "SaveImage",
+        "inputs": {
+            "images": ["6", 0],
+            "filename_prefix": "content_engine_img2img"
+        }
+    }
+}

requirements.txt

@@ -0,0 +1,15 @@
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+aiohttp>=3.9.0
+sqlalchemy>=2.0.0
+aiosqlite>=0.19.0
+pydantic>=2.5.0
+pydantic-settings>=2.1.0
+jinja2>=3.1.0
+Pillow>=10.2.0
+httpx>=0.26.0
+pyyaml>=6.0
+python-multipart>=0.0.6
+python-dotenv>=1.0.0
+runpod>=1.6.0
+paramiko>=3.4.0

src/content_engine.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: content-engine
+Version: 0.1.0
+Summary: Automated content generation system using ComfyUI
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.109.0
+Requires-Dist: uvicorn[standard]>=0.27.0
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: alembic>=1.13.0
+Requires-Dist: aiosqlite>=0.19.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: pydantic-settings>=2.1.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: Pillow>=10.2.0
+Requires-Dist: apscheduler>=3.10.0
+Requires-Dist: httpx>=0.26.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: python-multipart>=0.0.6
+Provides-Extra: cloud
+Requires-Dist: replicate>=0.22.0; extra == "cloud"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: httpx>=0.26.0; extra == "dev"

src/content_engine.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+pyproject.toml
+src/content_engine/__init__.py
+src/content_engine/config.py
+src/content_engine/main.py
+src/content_engine.egg-info/PKG-INFO
+src/content_engine.egg-info/SOURCES.txt
+src/content_engine.egg-info/dependency_links.txt
+src/content_engine.egg-info/requires.txt
+src/content_engine.egg-info/top_level.txt
+src/content_engine/api/__init__.py
+src/content_engine/api/routes_catalog.py
+src/content_engine/api/routes_generation.py
+src/content_engine/api/routes_system.py
+src/content_engine/models/__init__.py
+src/content_engine/models/database.py
+src/content_engine/models/schemas.py
+src/content_engine/services/__init__.py
+src/content_engine/services/catalog.py
+src/content_engine/services/comfyui_client.py
+src/content_engine/services/router.py
+src/content_engine/services/template_engine.py
+src/content_engine/services/variation_engine.py
+src/content_engine/services/workflow_builder.py
+src/content_engine/services/cloud_providers/__init__.py
+src/content_engine/services/cloud_providers/base.py
+src/content_engine/services/publisher/__init__.py
+src/content_engine/services/publisher/base.py
+src/content_engine/workers/__init__.py
+src/content_engine/workers/cloud_worker.py
+src/content_engine/workers/local_worker.py

src/content_engine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src/content_engine.egg-info/requires.txt

@@ -0,0 +1,22 @@
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+aiohttp>=3.9.0
+sqlalchemy>=2.0.0
+alembic>=1.13.0
+aiosqlite>=0.19.0
+pydantic>=2.5.0
+pydantic-settings>=2.1.0
+jinja2>=3.1.0
+Pillow>=10.2.0
+apscheduler>=3.10.0
+httpx>=0.26.0
+pyyaml>=6.0
+python-multipart>=0.0.6
+
+[cloud]
+replicate>=0.22.0
+
+[dev]
+pytest>=7.4.0
+pytest-asyncio>=0.23.0
+httpx>=0.26.0

src/content_engine.egg-info/top_level.txt

@@ -0,0 +1 @@
+content_engine

src/content_engine/__init__.py

@@ -0,0 +1,3 @@
+"""Content Engine - Automated content generation system using ComfyUI."""
+
+__version__ = "0.1.0"

src/content_engine/api/__init__.py

@@ -0,0 +1 @@
+"""FastAPI route modules."""

src/content_engine/api/routes_catalog.py

@@ -0,0 +1,169 @@
+"""Catalog API routes — query and manage generated images."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+from content_engine.models.schemas import ImageResponse
+
+router = APIRouter(prefix="/api", tags=["catalog"])
+
+_catalog = None
+
+
+def init_routes(catalog):
+    """Initialize route dependencies."""
+    global _catalog
+    _catalog = catalog
+
+
+@router.get("/images", response_model=list[ImageResponse])
+async def list_images(
+    character_id: str | None = None,
+    content_rating: str | None = None,
+    template_id: str | None = None,
+    is_approved: bool | None = None,
+    is_published: bool | None = None,
+    pose: str | None = None,
+    outfit: str | None = None,
+    emotion: str | None = None,
+    limit: int = 50,
+    offset: int = 0,
+):
+    """Search and list generated images with optional filters."""
+    if _catalog is None:
+        raise HTTPException(503, "Catalog not initialized")
+
+    images = await _catalog.search(
+        character_id=character_id,
+        content_rating=content_rating,
+        template_id=template_id,
+        is_approved=is_approved,
+        is_published=is_published,
+        pose=pose,
+        outfit=outfit,
+        emotion=emotion,
+        limit=limit,
+        offset=offset,
+    )
+
+    return [
+        ImageResponse(
+            id=img.id,
+            character_id=img.character_id,
+            template_id=img.template_id,
+            content_rating=img.content_rating,
+            file_path=img.file_path,
+            seed=img.seed,
+            pose=img.pose,
+            outfit=img.outfit,
+            emotion=img.emotion,
+            camera_angle=img.camera_angle,
+            lighting=img.lighting,
+            scene=img.scene,
+            quality_score=img.quality_score,
+            is_approved=img.is_approved,
+            is_published=img.is_published,
+            created_at=img.created_at,
+        )
+        for img in images
+    ]
+
+
+@router.get("/images/{image_id}", response_model=ImageResponse)
+async def get_image(image_id: str):
+    """Get a single image by ID."""
+    if _catalog is None:
+        raise HTTPException(503, "Catalog not initialized")
+
+    img = await _catalog.get_image(image_id)
+    if img is None:
+        raise HTTPException(404, f"Image not found: {image_id}")
+
+    return ImageResponse(
+        id=img.id,
+        character_id=img.character_id,
+        template_id=img.template_id,
+        content_rating=img.content_rating,
+        file_path=img.file_path,
+        seed=img.seed,
+        pose=img.pose,
+        outfit=img.outfit,
+        emotion=img.emotion,
+        camera_angle=img.camera_angle,
+        lighting=img.lighting,
+        scene=img.scene,
+        quality_score=img.quality_score,
+        is_approved=img.is_approved,
+        is_published=img.is_published,
+        created_at=img.created_at,
+    )
+
+
+@router.get("/images/{image_id}/file")
+async def serve_image_file(image_id: str):
+    """Serve the actual image file for display in the UI."""
+    if _catalog is None:
+        raise HTTPException(503, "Catalog not initialized")
+
+    img = await _catalog.get_image(image_id)
+    if img is None:
+        raise HTTPException(404, f"Image not found: {image_id}")
+
+    file_path = Path(img.file_path)
+    if not file_path.exists():
+        raise HTTPException(404, f"Image file not found on disk")
+
+    return FileResponse(
+        file_path,
+        media_type="image/png",
+        headers={"Cache-Control": "public, max-age=3600"},
+    )
+
+
+@router.get("/images/{image_id}/download")
+async def download_image_file(image_id: str):
+    """Download the image file as an attachment."""
+    if _catalog is None:
+        raise HTTPException(503, "Catalog not initialized")
+
+    img = await _catalog.get_image(image_id)
+    if img is None:
+        raise HTTPException(404, f"Image not found: {image_id}")
+
+    file_path = Path(img.file_path)
+    if not file_path.exists():
+        raise HTTPException(404, "Image file not found on disk")
+
+    return FileResponse(
+        file_path,
+        media_type="image/png",
+        filename=file_path.name,
+    )
+
+
+@router.post("/images/{image_id}/approve")
+async def approve_image(image_id: str):
+    """Mark an image as approved for publishing."""
+    if _catalog is None:
+        raise HTTPException(503, "Catalog not initialized")
+
+    success = await _catalog.approve_image(image_id)
+    if not success:
+        raise HTTPException(404, f"Image not found: {image_id}")
+    return {"status": "approved", "image_id": image_id}
+
+
+@router.delete("/images/{image_id}")
+async def delete_image(image_id: str):
+    """Delete an image from the catalog and disk."""
+    if _catalog is None:
+        raise HTTPException(503, "Catalog not initialized")
+
+    success = await _catalog.delete_image(image_id)
+    if not success:
+        raise HTTPException(404, f"Image not found: {image_id}")
+    return {"status": "deleted", "image_id": image_id}

src/content_engine/api/routes_generation.py

@@ -0,0 +1,604 @@
+"""Generation API routes — submit single and batch image generation jobs."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
+
+from content_engine.models.schemas import (
+    BatchRequest,
+    BatchStatusResponse,
+    GenerationRequest,
+    GenerationResponse,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api", tags=["generation"])
+
+# These are injected at startup from main.py
+_local_worker = None
+_template_engine = None
+_variation_engine = None
+_character_profiles = None
+_wavespeed_provider = None
+_runpod_provider = None
+_catalog = None
+_comfyui_client = None
+
+# In-memory batch tracking (v1 — move to DB for production)
+_batch_tracker: dict[str, dict] = {}
+
+
+def init_routes(local_worker, template_engine, variation_engine, character_profiles,
+                wavespeed_provider=None, catalog=None, comfyui_client=None):
+    """Initialize route dependencies. Called from main.py on startup."""
+    global _local_worker, _template_engine, _variation_engine, _character_profiles
+    global _wavespeed_provider, _catalog, _comfyui_client
+    _local_worker = local_worker
+    _template_engine = template_engine
+    _variation_engine = variation_engine
+    _character_profiles = character_profiles
+    _wavespeed_provider = wavespeed_provider
+    _catalog = catalog
+    _comfyui_client = comfyui_client
+
+
+def set_runpod_provider(provider):
+    """Set RunPod generation provider. Called from main.py after init_routes."""
+    global _runpod_provider
+    _runpod_provider = provider
+
+
+@router.post("/generate", response_model=GenerationResponse)
+async def generate_single(request: GenerationRequest):
+    """Submit a single image generation job.
+
+    The job runs asynchronously — returns immediately with a job ID.
+    """
+    if _local_worker is None:
+        raise HTTPException(503, "Worker not initialized")
+
+    job_id = str(uuid.uuid4())
+
+    # Fire and forget — run in background
+    asyncio.create_task(
+        _run_generation(
+            job_id=job_id,
+            character_id=request.character_id,
+            template_id=request.template_id,
+            content_rating=request.content_rating,
+            positive_prompt=request.positive_prompt,
+            negative_prompt=request.negative_prompt,
+            checkpoint=request.checkpoint,
+            loras=[l.model_dump() for l in request.loras] if request.loras else None,
+            seed=request.seed or -1,
+            steps=request.steps,
+            cfg=request.cfg,
+            sampler=request.sampler,
+            scheduler=request.scheduler,
+            width=request.width,
+            height=request.height,
+            variables=request.variables,
+        )
+    )
+
+    return GenerationResponse(job_id=job_id, status="queued", backend="local")
+
+
+@router.post("/batch", response_model=GenerationResponse)
+async def generate_batch(request: BatchRequest):
+    """Submit a batch of variation-based generation jobs.
+
+    Uses the variation engine to generate multiple images with
+    different poses, outfits, emotions, etc.
+    """
+    if _local_worker is None or _variation_engine is None:
+        raise HTTPException(503, "Services not initialized")
+    if _character_profiles is None:
+        raise HTTPException(503, "No character profiles loaded")
+
+    character = _character_profiles.get(request.character_id)
+    if character is None:
+        raise HTTPException(404, f"Character not found: {request.character_id}")
+
+    # Generate variation jobs
+    jobs = _variation_engine.generate_batch(
+        template_id=request.template_id,
+        character=character,
+        content_rating=request.content_rating,
+        count=request.count,
+        variation_mode=request.variation_mode,
+        pin=request.pin,
+        seed_strategy=request.seed_strategy,
+    )
+
+    batch_id = jobs[0].batch_id if jobs else str(uuid.uuid4())
+    _batch_tracker[batch_id] = {
+        "total": len(jobs),
+        "completed": 0,
+        "failed": 0,
+        "pending": len(jobs),
+        "running": 0,
+    }
+
+    # Fire all jobs in background
+    for job in jobs:
+        asyncio.create_task(
+            _run_batch_job(batch_id, job)
+        )
+
+    logger.info("Batch %s: %d jobs queued", batch_id, len(jobs))
+    return GenerationResponse(
+        job_id=batch_id, batch_id=batch_id, status="queued", backend="local"
+    )
+
+
+@router.get("/batch/{batch_id}/status", response_model=BatchStatusResponse)
+async def get_batch_status(batch_id: str):
+    """Get the status of a batch generation."""
+    if batch_id not in _batch_tracker:
+        raise HTTPException(404, f"Batch not found: {batch_id}")
+    tracker = _batch_tracker[batch_id]
+    return BatchStatusResponse(
+        batch_id=batch_id,
+        total_jobs=tracker["total"],
+        completed=tracker["completed"],
+        failed=tracker["failed"],
+        pending=tracker["pending"],
+        running=tracker["running"],
+    )
+
+
+@router.post("/generate/cloud", response_model=GenerationResponse)
+async def generate_cloud(request: GenerationRequest):
+    """Generate an image using WaveSpeed cloud API (NanoBanana, SeeDream).
+
+    Supported models via the 'checkpoint' field:
+    - nano-banana, nano-banana-pro
+    - seedream-3, seedream-3.1, seedream-4, seedream-4.5
+    """
+    if _wavespeed_provider is None:
+        raise HTTPException(503, "WaveSpeed cloud provider not configured. Set WAVESPEED_API_KEY in .env")
+
+    job_id = str(uuid.uuid4())
+
+    asyncio.create_task(
+        _run_cloud_generation(
+            job_id=job_id,
+            positive_prompt=request.positive_prompt or "",
+            negative_prompt=request.negative_prompt or "",
+            model=request.checkpoint,  # Use checkpoint field for model selection
+            width=request.width or 1024,
+            height=request.height or 1024,
+            seed=request.seed or -1,
+            content_rating=request.content_rating,
+            character_id=request.character_id,
+            template_id=request.template_id,
+            variables=request.variables,
+        )
+    )
+
+    return GenerationResponse(job_id=job_id, status="queued", backend="wavespeed")
+
+
+@router.get("/cloud/models")
+async def list_cloud_models():
+    """List available cloud models (WaveSpeed and RunPod)."""
+    return {
+        "wavespeed": {
+            "available": _wavespeed_provider is not None,
+            "models": [
+                {"id": "nano-banana", "name": "NanoBanana", "provider": "Google", "type": "txt2img"},
+                {"id": "nano-banana-pro", "name": "NanoBanana Pro", "provider": "Google", "type": "txt2img"},
+                {"id": "seedream-3", "name": "SeeDream v3", "provider": "ByteDance", "type": "txt2img"},
+                {"id": "seedream-3.1", "name": "SeeDream v3.1", "provider": "ByteDance", "type": "txt2img"},
+                {"id": "seedream-4", "name": "SeeDream v4", "provider": "ByteDance", "type": "txt2img"},
+                {"id": "seedream-4.5", "name": "SeeDream v4.5", "provider": "ByteDance", "type": "txt2img"},
+            ],
+            "edit_models": [
+                {"id": "seedream-4.5-edit", "name": "SeeDream v4.5 Edit", "provider": "ByteDance", "type": "img2img", "price": "$0.04/img"},
+                {"id": "seedream-4-edit", "name": "SeeDream v4 Edit", "provider": "ByteDance", "type": "img2img", "price": "$0.04/img"},
+                {"id": "nano-banana-edit", "name": "NanoBanana Edit", "provider": "Google", "type": "img2img", "price": "$0.038/img"},
+                {"id": "nano-banana-pro-edit", "name": "NanoBanana Pro Edit", "provider": "Google", "type": "img2img", "price": "$0.14/img"},
+            ],
+        },
+        "runpod": {
+            "available": _runpod_provider is not None,
+            "description": "Pay-per-second serverless GPU. Uses your deployed endpoint.",
+            "pricing": "~$0.00025/sec (RTX 4090)",
+        },
+    }
+
+
+@router.post("/generate/runpod", response_model=GenerationResponse)
+async def generate_runpod(request: GenerationRequest):
+    """Generate an image using RunPod serverless GPU.
+
+    Uses your deployed RunPod endpoint. Pay per second of GPU time.
+    Requires RUNPOD_API_KEY and RUNPOD_ENDPOINT_ID in .env.
+    """
+    if _runpod_provider is None:
+        raise HTTPException(
+            503,
+            "RunPod not configured. Set RUNPOD_API_KEY and RUNPOD_ENDPOINT_ID in .env"
+        )
+
+    job_id = str(uuid.uuid4())
+
+    asyncio.create_task(
+        _run_runpod_generation(
+            job_id=job_id,
+            positive_prompt=request.positive_prompt or "",
+            negative_prompt=request.negative_prompt or "",
+            checkpoint=request.checkpoint,
+            loras=request.loras,
+            seed=request.seed or -1,
+            steps=request.steps or 28,
+            cfg=request.cfg or 7.0,
+            width=request.width or 832,
+            height=request.height or 1216,
+            character_id=request.character_id,
+            template_id=request.template_id,
+            content_rating=request.content_rating,
+        )
+    )
+
+    return GenerationResponse(job_id=job_id, status="queued", backend="runpod")
+
+
+@router.post("/generate/img2img", response_model=GenerationResponse)
+async def generate_img2img(
+    image: UploadFile = File(...),
+    positive_prompt: str = Form(""),
+    negative_prompt: str = Form(""),
+    character_id: str | None = Form(None),
+    template_id: str | None = Form(None),
+    variables_json: str = Form("{}"),
+    content_rating: str = Form("sfw"),
+    checkpoint: str | None = Form(None),
+    seed: int = Form(-1),
+    steps: int = Form(28),
+    cfg: float = Form(7.0),
+    denoise: float = Form(0.65),
+    width: int | None = Form(None),
+    height: int | None = Form(None),
+    backend: str = Form("local"),
+):
+    """Generate an image using a reference image (img2img).
+
+    Supports both local (ComfyUI) and cloud (WaveSpeed edit) backends.
+    - Local: denoise-based img2img via ComfyUI
+    - Cloud: prompt-guided editing via SeeDream/NanoBanana Edit APIs
+    """
+    import json as json_module
+
+    job_id = str(uuid.uuid4())
+    image_bytes = await image.read()
+
+    # Parse template variables
+    try:
+        variables = json_module.loads(variables_json) if variables_json else {}
+    except json_module.JSONDecodeError:
+        variables = {}
+
+    if backend == "cloud":
+        # Cloud img2img via WaveSpeed Edit API
+        if _wavespeed_provider is None:
+            raise HTTPException(503, "WaveSpeed cloud provider not configured. Set WAVESPEED_API_KEY in .env")
+
+        asyncio.create_task(
+            _run_cloud_img2img(
+                job_id=job_id,
+                image_bytes=image_bytes,
+                positive_prompt=positive_prompt,
+                model=checkpoint,
+                content_rating=content_rating,
+                character_id=character_id,
+                template_id=template_id,
+                variables=variables,
+                width=width,
+                height=height,
+            )
+        )
+        return GenerationResponse(job_id=job_id, status="queued", backend="wavespeed")
+
+    # Local img2img via ComfyUI
+    if _local_worker is None or _comfyui_client is None:
+        raise HTTPException(503, "Worker not initialized")
+
+    ref_filename = f"ref_{job_id[:8]}.png"
+
+    try:
+        uploaded_name = await _comfyui_client.upload_image(image_bytes, ref_filename)
+    except Exception as e:
+        raise HTTPException(500, f"Failed to upload reference image to ComfyUI: {e}")
+
+    asyncio.create_task(
+        _run_generation(
+            job_id=job_id,
+            character_id=character_id,
+            template_id=template_id,
+            variables=variables,
+            content_rating=content_rating,
+            positive_prompt=positive_prompt,
+            negative_prompt=negative_prompt,
+            checkpoint=checkpoint,
+            seed=seed,
+            steps=steps,
+            cfg=cfg,
+            width=width,
+            height=height,
+            denoise=denoise,
+            reference_image=uploaded_name,
+            mode="img2img",
+        )
+    )
+
+    return GenerationResponse(job_id=job_id, status="queued", backend="local")
+
+
+async def _run_cloud_generation(
+    *,
+    job_id: str,
+    positive_prompt: str,
+    negative_prompt: str,
+    model: str | None,
+    width: int,
+    height: int,
+    seed: int,
+    content_rating: str,
+    character_id: str | None,
+    template_id: str | None,
+    variables: dict | None,
+):
+    """Background task to run a WaveSpeed cloud generation."""
+    try:
+        # Apply template rendering if a template is selected
+        final_positive = positive_prompt
+        final_negative = negative_prompt
+        if template_id and _template_engine:
+            try:
+                rendered = _template_engine.render(template_id, variables or {})
+                # Template prompt becomes the base; user prompt is appended if provided
+                final_positive = rendered.positive_prompt
+                if positive_prompt:
+                    final_positive = f"{final_positive}, {positive_prompt}"
+                final_negative = rendered.negative_prompt
+                if negative_prompt:
+                    final_negative = f"{final_negative}, {negative_prompt}"
+                # Use template dimensions if user didn't override
+                if rendered.template.width:
+                    width = rendered.template.width
+                if rendered.template.height:
+                    height = rendered.template.height
+                logger.info("Cloud gen: applied template '%s'", template_id)
+            except Exception:
+                logger.warning("Failed to render template '%s', using raw prompt", template_id, exc_info=True)
+
+        result = await _wavespeed_provider.generate(
+            positive_prompt=final_positive,
+            negative_prompt=final_negative,
+            model=model,
+            width=width,
+            height=height,
+            seed=seed,
+        )
+
+        if _catalog:
+            # Save image to disk
+            output_path = _catalog.resolve_output_path(
+                character_id=character_id or "cloud",
+                content_rating=content_rating,
+                filename=f"wavespeed_{job_id[:8]}.png",
+            )
+            output_path.write_bytes(result.image_bytes)
+
+            # Record in catalog
+            await _catalog.insert_image(
+                file_path=str(output_path),
+                image_bytes=result.image_bytes,
+                character_id=character_id,
+                template_id=template_id,
+                content_rating=content_rating,
+                positive_prompt=positive_prompt,
+                negative_prompt=negative_prompt,
+                checkpoint=model or "seedream-4.5",
+                seed=seed if seed >= 0 else None,
+                width=width,
+                height=height,
+                generation_backend="wavespeed",
+                generation_time_seconds=result.generation_time_seconds,
+                variables=variables,
+            )
+            logger.info("Cloud generation saved: %s", output_path)
+
+    except Exception:
+        logger.error("Cloud generation failed for job %s", job_id, exc_info=True)
+
+
+async def _run_cloud_img2img(
+    *,
+    job_id: str,
+    image_bytes: bytes,
+    positive_prompt: str,
+    model: str | None,
+    content_rating: str,
+    character_id: str | None,
+    template_id: str | None,
+    variables: dict | None,
+    width: int | None,
+    height: int | None,
+):
+    """Background task to run a WaveSpeed cloud image edit (img2img)."""
+    try:
+        # Apply template rendering if a template is selected
+        final_prompt = positive_prompt
+        if template_id and _template_engine:
+            try:
+                rendered = _template_engine.render(template_id, variables or {})
+                final_prompt = rendered.positive_prompt
+                if positive_prompt:
+                    final_prompt = f"{final_prompt}, {positive_prompt}"
+                logger.info("Cloud img2img: applied template '%s'", template_id)
+            except Exception:
+                logger.warning("Failed to render template '%s', using raw prompt", template_id, exc_info=True)
+
+        # Clean up prompt — remove empty Jinja2 artifacts and leading/trailing commas
+        final_prompt = ", ".join(p.strip() for p in final_prompt.split(",") if p.strip())
+
+        if not final_prompt:
+            logger.error("Cloud img2img: empty prompt after template rendering, cannot proceed")
+            return
+
+        # Build size string if dimensions provided
+        # WaveSpeed edit API requires output size >= 3686400 pixels (~1920x1920)
+        # If dimensions are too small, omit size to let API use input image dimensions
+        size = None
+        if width and height and (width * height) >= 3686400:
+            size = f"{width}x{height}"
+
+        result = await _wavespeed_provider.edit_image(
+            prompt=final_prompt,
+            image_bytes=image_bytes,
+            model=model,
+            size=size,
+        )
+
+        if _catalog:
+            output_path = _catalog.resolve_output_path(
+                character_id=character_id or "cloud",
+                content_rating=content_rating,
+                filename=f"wavespeed_edit_{job_id[:8]}.png",
+            )
+            output_path.write_bytes(result.image_bytes)
+
+            await _catalog.insert_image(
+                file_path=str(output_path),
+                image_bytes=result.image_bytes,
+                character_id=character_id,
+                template_id=template_id,
+                content_rating=content_rating,
+                positive_prompt=final_prompt,
+                negative_prompt="",
+                checkpoint=model or "seedream-4.5-edit",
+                width=width or 0,
+                height=height or 0,
+                generation_backend="wavespeed-edit",
+                generation_time_seconds=result.generation_time_seconds,
+                variables=variables,
+            )
+            logger.info("Cloud img2img saved: %s", output_path)
+
+    except Exception:
+        logger.error("Cloud img2img failed for job %s", job_id, exc_info=True)
+
+
+async def _run_runpod_generation(
+    *,
+    job_id: str,
+    positive_prompt: str,
+    negative_prompt: str,
+    checkpoint: str | None,
+    loras: list | None,
+    seed: int,
+    steps: int,
+    cfg: float,
+    width: int,
+    height: int,
+    character_id: str | None,
+    template_id: str | None,
+    content_rating: str,
+):
+    """Background task to run a generation on RunPod serverless."""
+    try:
+        # Resolve character/template prompts if provided
+        final_prompt = positive_prompt
+        final_negative = negative_prompt
+
+        if character_id and _character_profiles:
+            character = _character_profiles.get(character_id)
+            if character:
+                final_prompt = f"{character.trigger_word}, {positive_prompt}"
+
+        # Submit to RunPod
+        runpod_job_id = await _runpod_provider.submit_generation(
+            positive_prompt=final_prompt,
+            negative_prompt=final_negative,
+            checkpoint=checkpoint or "realisticVisionV51_v51VAE",
+            lora_name=loras[0].name if loras else None,
+            lora_strength=loras[0].strength if loras else 0.85,
+            seed=seed,
+            steps=steps,
+            cfg=cfg,
+            width=width,
+            height=height,
+        )
+
+        # Wait for completion and get result
+        result = await _runpod_provider.wait_for_completion(runpod_job_id)
+
+        # Save to catalog
+        if _catalog:
+            from pathlib import Path
+            output_path = await _catalog.insert_image(
+                image_bytes=result.image_bytes,
+                character_id=character_id or "unknown",
+                content_rating=content_rating,
+                job_id=job_id,
+                positive_prompt=final_prompt,
+                negative_prompt=final_negative,
+                checkpoint=checkpoint,
+                seed=seed,
+                steps=steps,
+                cfg=cfg,
+                width=width,
+                height=height,
+                generation_backend="runpod",
+                generation_time_seconds=result.generation_time_seconds,
+            )
+            logger.info("RunPod generation saved: %s (%.1fs)", output_path, result.generation_time_seconds)
+
+    except Exception:
+        logger.error("RunPod generation failed for job %s", job_id, exc_info=True)
+
+
+async def _run_generation(**kwargs):
+    """Background task to run a single local generation."""
+    try:
+        # Remove mode param — it's used by the router, not the worker
+        kwargs.pop("mode", None)
+        await _local_worker.process_job(**kwargs)
+    except Exception:
+        logger.error("Generation failed for job %s", kwargs.get("job_id"), exc_info=True)
+
+
+async def _run_batch_job(batch_id: str, job):
+    """Background task to run a single job within a batch."""
+    tracker = _batch_tracker.get(batch_id)
+    if tracker:
+        tracker["pending"] -= 1
+        tracker["running"] += 1
+    try:
+        await _local_worker.process_job(
+            job_id=job.job_id,
+            batch_id=job.batch_id,
+            character_id=job.character.id,
+            template_id=job.template_id,
+            content_rating=job.content_rating,
+            loras=[l for l in job.loras],
+            seed=job.seed,
+            variables=job.variables,
+        )
+        if tracker:
+            tracker["completed"] += 1
+    except Exception:
+        logger.error("Batch job %s failed", job.job_id, exc_info=True)
+        if tracker:
+            tracker["failed"] += 1
+    finally:
+        if tracker:
+            tracker["running"] -= 1

src/content_engine/api/routes_pod.py

@@ -0,0 +1,545 @@
+"""RunPod Pod management routes — start/stop GPU pods for generation and training."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import time
+import uuid
+from typing import Any
+
+import runpod
+from fastapi import APIRouter, File, HTTPException, UploadFile
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/pod", tags=["pod"])
+
+# Pod state
+_pod_state = {
+    "pod_id": None,
+    "status": "stopped",  # stopped, starting, running, stopping
+    "ip": None,
+    "port": None,
+    "gpu_type": "NVIDIA GeForce RTX 4090",
+    "started_at": None,
+    "cost_per_hour": 0.44,
+}
+
+# Docker image with ComfyUI + FLUX
+COMFYUI_IMAGE = "timpietruskyblibla/runpod-worker-comfy:3.4.0-flux1-dev"
+
+# GPU options
+GPU_OPTIONS = {
+    "NVIDIA GeForce RTX 4090": {"name": "RTX 4090", "vram": 24, "cost": 0.44},
+    "NVIDIA RTX A6000": {"name": "RTX A6000", "vram": 48, "cost": 0.76},
+    "NVIDIA A100 80GB PCIe": {"name": "A100 80GB", "vram": 80, "cost": 1.89},
+}
+
+
+def _get_api_key() -> str:
+    key = os.environ.get("RUNPOD_API_KEY")
+    if not key:
+        raise HTTPException(503, "RUNPOD_API_KEY not configured")
+    runpod.api_key = key
+    return key
+
+
+class StartPodRequest(BaseModel):
+    gpu_type: str = "NVIDIA GeForce RTX 4090"
+
+
+class PodStatus(BaseModel):
+    status: str
+    pod_id: str | None = None
+    ip: str | None = None
+    port: int | None = None
+    gpu_type: str | None = None
+    cost_per_hour: float | None = None
+    uptime_minutes: float | None = None
+    comfyui_url: str | None = None
+
+
+@router.get("/status", response_model=PodStatus)
+async def get_pod_status():
+    """Get current pod status."""
+    _get_api_key()
+
+    # If we have a pod_id, check its actual status
+    if _pod_state["pod_id"]:
+        try:
+            pod = runpod.get_pod(_pod_state["pod_id"])
+            if pod:
+                desired = pod.get("desiredStatus", "")
+                if desired == "RUNNING":
+                    runtime = pod.get("runtime", {})
+                    ports = runtime.get("ports", [])
+                    for p in ports:
+                        if p.get("privatePort") == 8188:
+                            _pod_state["ip"] = p.get("ip")
+                            _pod_state["port"] = p.get("publicPort")
+                    _pod_state["status"] = "running"
+                elif desired == "EXITED":
+                    _pod_state["status"] = "stopped"
+                    _pod_state["pod_id"] = None
+            else:
+                _pod_state["status"] = "stopped"
+                _pod_state["pod_id"] = None
+        except Exception as e:
+            logger.warning("Failed to check pod: %s", e)
+
+    uptime = None
+    if _pod_state["started_at"] and _pod_state["status"] == "running":
+        uptime = (time.time() - _pod_state["started_at"]) / 60
+
+    comfyui_url = None
+    if _pod_state["ip"] and _pod_state["port"]:
+        comfyui_url = f"http://{_pod_state['ip']}:{_pod_state['port']}"
+
+    return PodStatus(
+        status=_pod_state["status"],
+        pod_id=_pod_state["pod_id"],
+        ip=_pod_state["ip"],
+        port=_pod_state["port"],
+        gpu_type=_pod_state["gpu_type"],
+        cost_per_hour=_pod_state["cost_per_hour"],
+        uptime_minutes=uptime,
+        comfyui_url=comfyui_url,
+    )
+
+
+@router.get("/gpu-options")
+async def list_gpu_options():
+    """List available GPU types."""
+    return {"gpus": GPU_OPTIONS}
+
+
+@router.post("/start")
+async def start_pod(request: StartPodRequest):
+    """Start a GPU pod for generation/training."""
+    _get_api_key()
+
+    if _pod_state["status"] == "running":
+        return {"status": "already_running", "pod_id": _pod_state["pod_id"]}
+
+    if _pod_state["status"] == "starting":
+        return {"status": "starting", "message": "Pod is already starting"}
+
+    gpu_info = GPU_OPTIONS.get(request.gpu_type)
+    if not gpu_info:
+        raise HTTPException(400, f"Unknown GPU type: {request.gpu_type}")
+
+    _pod_state["status"] = "starting"
+    _pod_state["gpu_type"] = request.gpu_type
+    _pod_state["cost_per_hour"] = gpu_info["cost"]
+
+    try:
+        logger.info("Starting RunPod with %s...", request.gpu_type)
+
+        pod = runpod.create_pod(
+            name="content-engine-gpu",
+            image_name=COMFYUI_IMAGE,
+            gpu_type_id=request.gpu_type,
+            volume_in_gb=50,  # For models and LoRAs
+            container_disk_in_gb=20,
+            ports="8188/http",
+            env={
+                # Pre-load FLUX model
+                "MODEL_URL": "https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/flux1-dev.safetensors",
+            },
+        )
+
+        _pod_state["pod_id"] = pod["id"]
+        _pod_state["started_at"] = time.time()
+
+        logger.info("Pod created: %s", pod["id"])
+
+        # Start background task to wait for pod ready
+        asyncio.create_task(_wait_for_pod_ready(pod["id"]))
+
+        return {
+            "status": "starting",
+            "pod_id": pod["id"],
+            "message": f"Starting {gpu_info['name']} pod (~2-3 min)",
+        }
+
+    except Exception as e:
+        _pod_state["status"] = "stopped"
+        logger.error("Failed to start pod: %s", e)
+        raise HTTPException(500, f"Failed to start pod: {e}")
+
+
+async def _wait_for_pod_ready(pod_id: str, timeout: int = 300):
+    """Background task to wait for pod to be ready."""
+    start = time.time()
+
+    while time.time() - start < timeout:
+        try:
+            pod = runpod.get_pod(pod_id)
+
+            if pod and pod.get("desiredStatus") == "RUNNING":
+                runtime = pod.get("runtime", {})
+                ports = runtime.get("ports", [])
+
+                for p in ports:
+                    if p.get("privatePort") == 8188:
+                        ip = p.get("ip")
+                        port = p.get("publicPort")
+
+                        if ip and port:
+                            _pod_state["ip"] = ip
+                            _pod_state["port"] = int(port)
+                            _pod_state["status"] = "running"
+                            logger.info("Pod ready at %s:%s", ip, port)
+                            return
+
+        except Exception as e:
+            logger.debug("Waiting for pod: %s", e)
+
+        await asyncio.sleep(5)
+
+    logger.error("Pod did not become ready within %ds", timeout)
+    _pod_state["status"] = "stopped"
+
+
+@router.post("/stop")
+async def stop_pod():
+    """Stop the GPU pod."""
+    _get_api_key()
+
+    if not _pod_state["pod_id"]:
+        return {"status": "already_stopped"}
+
+    if _pod_state["status"] == "stopping":
+        return {"status": "stopping", "message": "Pod is already stopping"}
+
+    _pod_state["status"] = "stopping"
+
+    try:
+        pod_id = _pod_state["pod_id"]
+        logger.info("Stopping pod: %s", pod_id)
+
+        runpod.terminate_pod(pod_id)
+
+        _pod_state["pod_id"] = None
+        _pod_state["ip"] = None
+        _pod_state["port"] = None
+        _pod_state["status"] = "stopped"
+        _pod_state["started_at"] = None
+
+        logger.info("Pod stopped")
+        return {"status": "stopped", "message": "Pod terminated"}
+
+    except Exception as e:
+        logger.error("Failed to stop pod: %s", e)
+        _pod_state["status"] = "running"  # Revert
+        raise HTTPException(500, f"Failed to stop pod: {e}")
+
+
+@router.get("/loras")
+async def list_pod_loras():
+    """List LoRAs available on the pod."""
+    if _pod_state["status"] != "running" or not _pod_state["ip"]:
+        return {"loras": [], "message": "Pod not running"}
+
+    try:
+        import httpx
+        async with httpx.AsyncClient(timeout=30) as client:
+            url = f"http://{_pod_state['ip']}:{_pod_state['port']}/object_info/LoraLoader"
+            resp = await client.get(url)
+            if resp.status_code == 200:
+                data = resp.json()
+                loras = data.get("LoraLoader", {}).get("input", {}).get("required", {}).get("lora_name", [[]])[0]
+                return {"loras": loras if isinstance(loras, list) else []}
+    except Exception as e:
+        logger.warning("Failed to list pod LoRAs: %s", e)
+
+    return {"loras": [], "comfyui_url": f"http://{_pod_state['ip']}:{_pod_state['port']}"}
+
+
+@router.post("/upload-lora")
+async def upload_lora_to_pod(
+    file: UploadFile = File(...),
+):
+    """Upload a LoRA file to the running pod."""
+    from fastapi import UploadFile, File
+    import httpx
+
+    if _pod_state["status"] != "running":
+        raise HTTPException(400, "Pod not running - start it first")
+
+    if not file.filename.endswith(".safetensors"):
+        raise HTTPException(400, "Only .safetensors files supported")
+
+    try:
+        content = await file.read()
+
+        async with httpx.AsyncClient(timeout=120) as client:
+            # Upload to ComfyUI's models/loras directory
+            url = f"http://{_pod_state['ip']}:{_pod_state['port']}/upload/image"
+            files = {"image": (file.filename, content, "application/octet-stream")}
+            data = {"subfolder": "loras", "type": "input"}
+
+            resp = await client.post(url, files=files, data=data)
+
+            if resp.status_code == 200:
+                return {"status": "uploaded", "filename": file.filename}
+            else:
+                raise HTTPException(500, f"Upload failed: {resp.text}")
+
+    except httpx.TimeoutException:
+        raise HTTPException(504, "Upload timed out")
+    except Exception as e:
+        raise HTTPException(500, f"Upload failed: {e}")
+
+
+class PodGenerateRequest(BaseModel):
+    prompt: str
+    negative_prompt: str = ""
+    width: int = 1024
+    height: int = 1024
+    steps: int = 28
+    cfg: float = 3.5
+    seed: int = -1
+    lora_name: str | None = None
+    lora_strength: float = 0.85
+    character_id: str | None = None
+    template_id: str | None = None
+    content_rating: str = "sfw"
+
+
+# In-memory job tracking for pod generation
+_pod_jobs: dict[str, dict] = {}
+
+
+@router.post("/generate")
+async def generate_on_pod(request: PodGenerateRequest):
+    """Generate an image using the running pod's ComfyUI."""
+    import httpx
+    import random
+
+    if _pod_state["status"] != "running":
+        raise HTTPException(400, "Pod not running - start it first")
+
+    job_id = str(uuid.uuid4())[:8]
+    seed = request.seed if request.seed >= 0 else random.randint(0, 2**32 - 1)
+
+    # Build ComfyUI workflow
+    workflow = _build_flux_workflow(
+        prompt=request.prompt,
+        negative_prompt=request.negative_prompt,
+        width=request.width,
+        height=request.height,
+        steps=request.steps,
+        cfg=request.cfg,
+        seed=seed,
+        lora_name=request.lora_name,
+        lora_strength=request.lora_strength,
+    )
+
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            url = f"http://{_pod_state['ip']}:{_pod_state['port']}/prompt"
+            resp = await client.post(url, json={"prompt": workflow})
+            resp.raise_for_status()
+
+            data = resp.json()
+            prompt_id = data["prompt_id"]
+
+            _pod_jobs[job_id] = {
+                "prompt_id": prompt_id,
+                "status": "running",
+                "seed": seed,
+                "started_at": time.time(),
+            }
+
+            logger.info("Pod generation started: %s -> %s", job_id, prompt_id)
+
+            # Start background task to poll for completion
+            asyncio.create_task(_poll_pod_job(job_id, prompt_id, request.content_rating))
+
+            return {
+                "job_id": job_id,
+                "status": "running",
+                "seed": seed,
+            }
+
+    except Exception as e:
+        logger.error("Pod generation failed: %s", e)
+        raise HTTPException(500, f"Generation failed: {e}")
+
+
+async def _poll_pod_job(job_id: str, prompt_id: str, content_rating: str):
+    """Poll ComfyUI for job completion and save the result."""
+    import httpx
+    from pathlib import Path
+
+    start = time.time()
+    timeout = 300  # 5 minutes
+
+    async with httpx.AsyncClient(timeout=60) as client:
+        while time.time() - start < timeout:
+            try:
+                url = f"http://{_pod_state['ip']}:{_pod_state['port']}/history/{prompt_id}"
+                resp = await client.get(url)
+
+                if resp.status_code == 200:
+                    data = resp.json()
+                    if prompt_id in data:
+                        outputs = data[prompt_id].get("outputs", {})
+
+                        # Find SaveImage output
+                        for node_id, node_output in outputs.items():
+                            if "images" in node_output:
+                                image_info = node_output["images"][0]
+                                filename = image_info["filename"]
+                                subfolder = image_info.get("subfolder", "")
+
+                                # Download the image
+                                img_url = f"http://{_pod_state['ip']}:{_pod_state['port']}/view"
+                                params = {"filename": filename}
+                                if subfolder:
+                                    params["subfolder"] = subfolder
+
+                                img_resp = await client.get(img_url, params=params)
+                                if img_resp.status_code == 200:
+                                    # Save to local output directory
+                                    from content_engine.config import settings
+                                    output_dir = settings.paths.output_dir / "pod" / content_rating / "raw"
+                                    output_dir.mkdir(parents=True, exist_ok=True)
+
+                                    local_path = output_dir / f"pod_{job_id}.png"
+                                    local_path.write_bytes(img_resp.content)
+
+                                    _pod_jobs[job_id]["status"] = "completed"
+                                    _pod_jobs[job_id]["output_path"] = str(local_path)
+                                    _pod_jobs[job_id]["completed_at"] = time.time()
+
+                                    logger.info("Pod generation completed: %s -> %s", job_id, local_path)
+
+                                    # Catalog the image
+                                    try:
+                                        from content_engine.services.catalog import CatalogService
+                                        catalog = CatalogService()
+                                        await catalog.add_image(
+                                            image_path=local_path,
+                                            content_rating=content_rating,
+                                            seed=_pod_jobs[job_id].get("seed"),
+                                            backend="runpod-pod",
+                                        )
+                                    except Exception as e:
+                                        logger.warning("Failed to catalog pod image: %s", e)
+
+                                    return
+
+            except Exception as e:
+                logger.debug("Polling pod job: %s", e)
+
+            await asyncio.sleep(2)
+
+    _pod_jobs[job_id]["status"] = "failed"
+    _pod_jobs[job_id]["error"] = "Timeout waiting for generation"
+    logger.error("Pod generation timed out: %s", job_id)
+
+
+@router.get("/jobs/{job_id}")
+async def get_pod_job(job_id: str):
+    """Get status of a pod generation job."""
+    job = _pod_jobs.get(job_id)
+    if not job:
+        raise HTTPException(404, "Job not found")
+    return job
+
+
+def _build_flux_workflow(
+    prompt: str,
+    negative_prompt: str,
+    width: int,
+    height: int,
+    steps: int,
+    cfg: float,
+    seed: int,
+    lora_name: str | None,
+    lora_strength: float,
+) -> dict:
+    """Build a ComfyUI workflow for FLUX generation."""
+
+    # Basic FLUX workflow - compatible with ComfyUI FLUX setup
+    workflow = {
+        "4": {
+            "class_type": "CheckpointLoaderSimple",
+            "inputs": {"ckpt_name": "flux1-dev.safetensors"},
+        },
+        "6": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {
+                "text": prompt,
+                "clip": ["4", 1],
+            },
+        },
+        "7": {
+            "class_type": "CLIPTextEncode",
+            "inputs": {
+                "text": negative_prompt or "",
+                "clip": ["4", 1],
+            },
+        },
+        "5": {
+            "class_type": "EmptyLatentImage",
+            "inputs": {
+                "width": width,
+                "height": height,
+                "batch_size": 1,
+            },
+        },
+        "3": {
+            "class_type": "KSampler",
+            "inputs": {
+                "seed": seed,
+                "steps": steps,
+                "cfg": cfg,
+                "sampler_name": "euler",
+                "scheduler": "simple",
+                "denoise": 1.0,
+                "model": ["4", 0],
+                "positive": ["6", 0],
+                "negative": ["7", 0],
+                "latent_image": ["5", 0],
+            },
+        },
+        "8": {
+            "class_type": "VAEDecode",
+            "inputs": {
+                "samples": ["3", 0],
+                "vae": ["4", 2],
+            },
+        },
+        "9": {
+            "class_type": "SaveImage",
+            "inputs": {
+                "filename_prefix": "flux_pod",
+                "images": ["8", 0],
+            },
+        },
+    }
+
+    # Add LoRA if specified
+    if lora_name:
+        workflow["10"] = {
+            "class_type": "LoraLoader",
+            "inputs": {
+                "lora_name": lora_name,
+                "strength_model": lora_strength,
+                "strength_clip": lora_strength,
+                "model": ["4", 0],
+                "clip": ["4", 1],
+            },
+        }
+        # Rewire sampler to use LoRA output
+        workflow["3"]["inputs"]["model"] = ["10", 0]
+        workflow["6"]["inputs"]["clip"] = ["10", 1]
+        workflow["7"]["inputs"]["clip"] = ["10", 1]
+
+    return workflow

src/content_engine/api/routes_system.py

@@ -0,0 +1,235 @@
+"""System API routes — health checks, status, and configuration."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from content_engine.models.schemas import SystemStatus
+from content_engine.config import IS_HF_SPACES
+
+router = APIRouter(prefix="/api", tags=["system"])
+
+_comfyui_client = None
+_catalog = None
+_template_engine = None
+_character_profiles = None
+
+
+def init_routes(comfyui_client, catalog, template_engine, character_profiles=None):
+    """Initialize route dependencies."""
+    global _comfyui_client, _catalog, _template_engine, _character_profiles
+    _comfyui_client = comfyui_client
+    _catalog = catalog
+    _template_engine = template_engine
+    _character_profiles = character_profiles
+
+
+@router.get("/health")
+async def health_check():
+    """Basic health check."""
+    comfyui_ok = False
+    if _comfyui_client:
+        comfyui_ok = await _comfyui_client.is_available()
+    return {"status": "ok", "comfyui": comfyui_ok}
+
+
+@router.get("/status", response_model=SystemStatus)
+async def system_status():
+    """Get comprehensive system status."""
+    comfyui_connected = False
+    gpu_name = None
+    vram_total_gb = None
+    vram_free_gb = None
+    queue_depth = 0
+
+    if _comfyui_client:
+        comfyui_connected = await _comfyui_client.is_available()
+        if comfyui_connected:
+            try:
+                stats = await _comfyui_client.get_system_stats()
+                devices = stats.get("devices", [])
+                if devices:
+                    gpu_name = devices[0].get("name")
+                    vram_total_gb = devices[0].get("vram_total", 0) / (1024**3)
+                    vram_free_gb = devices[0].get("vram_free", 0) / (1024**3)
+                queue_depth = await _comfyui_client.get_queue_depth()
+            except Exception:
+                pass
+
+    total_images = 0
+    if _catalog:
+        total_images = await _catalog.get_total_count()
+
+    return SystemStatus(
+        comfyui_connected=comfyui_connected,
+        gpu_name=gpu_name,
+        vram_total_gb=round(vram_total_gb, 2) if vram_total_gb else None,
+        vram_free_gb=round(vram_free_gb, 2) if vram_free_gb else None,
+        local_queue_depth=queue_depth,
+        cloud_available=False,  # Phase 4
+        total_images=total_images,
+        pending_jobs=0,
+    )
+
+
+@router.get("/templates")
+async def list_templates():
+    """List all available prompt templates."""
+    if _template_engine is None:
+        return []
+    templates = _template_engine.list_templates()
+    return [
+        {
+            "id": t.id,
+            "name": t.name,
+            "category": t.category,
+            "rating": t.rating,
+            "variables": {
+                name: {
+                    "type": vdef.type,
+                    "options": vdef.options,
+                    "required": vdef.required,
+                }
+                for name, vdef in t.variables.items()
+            },
+        }
+        for t in templates
+    ]
+
+
+@router.get("/characters")
+async def list_characters():
+    """List all configured character profiles."""
+    if _character_profiles is None:
+        return []
+    return [
+        {
+            "id": c.id,
+            "name": c.name,
+            "trigger_word": c.trigger_word,
+            "lora_filename": c.lora_filename,
+            "lora_strength": c.lora_strength,
+            "description": c.description,
+        }
+        for c in _character_profiles.values()
+    ]
+
+
+@router.get("/models/loras")
+async def list_loras():
+    """List available LoRA models from ComfyUI."""
+    if _comfyui_client is None:
+        return []
+    try:
+        return await _comfyui_client.get_models("loras")
+    except Exception:
+        return []
+
+
+@router.get("/models/checkpoints")
+async def list_checkpoints():
+    """List available checkpoint models from ComfyUI."""
+    if _comfyui_client is None:
+        return []
+    try:
+        return await _comfyui_client.get_models("checkpoints")
+    except Exception:
+        return []
+
+
+# --- API Settings ---
+
+class APISettingsResponse(BaseModel):
+    runpod_configured: bool
+    runpod_key_preview: str | None = None
+    wavespeed_configured: bool
+    wavespeed_key_preview: str | None = None
+    is_cloud: bool
+    env_file_path: str | None = None
+
+
+class UpdateAPIKeysRequest(BaseModel):
+    runpod_api_key: str | None = None
+    wavespeed_api_key: str | None = None
+
+
+def _mask_key(key: str | None) -> str | None:
+    """Mask API key showing only last 4 chars."""
+    if not key:
+        return None
+    if len(key) <= 8:
+        return "****"
+    return f"****{key[-4:]}"
+
+
+@router.get("/settings/api", response_model=APISettingsResponse)
+async def get_api_settings():
+    """Get current API settings status (keys are masked)."""
+    runpod_key = os.environ.get("RUNPOD_API_KEY")
+    wavespeed_key = os.environ.get("WAVESPEED_API_KEY")
+
+    env_file = None
+    if not IS_HF_SPACES:
+        env_file = "D:/AI automation/content_engine/.env"
+
+    return APISettingsResponse(
+        runpod_configured=bool(runpod_key),
+        runpod_key_preview=_mask_key(runpod_key),
+        wavespeed_configured=bool(wavespeed_key),
+        wavespeed_key_preview=_mask_key(wavespeed_key),
+        is_cloud=IS_HF_SPACES,
+        env_file_path=env_file,
+    )
+
+
+@router.post("/settings/api")
+async def update_api_settings(request: UpdateAPIKeysRequest):
+    """Update API keys. Only works in local mode (not HF Spaces).
+
+    On HF Spaces, use the Settings > Secrets panel instead.
+    """
+    if IS_HF_SPACES:
+        raise HTTPException(
+            400,
+            "Cannot update API keys on Hugging Face Spaces. "
+            "Use Settings > Variables and secrets in your Space dashboard."
+        )
+
+    env_path = Path("D:/AI automation/content_engine/.env")
+
+    # Read existing .env
+    existing = {}
+    if env_path.exists():
+        with open(env_path) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, val = line.split("=", 1)
+                    existing[key.strip()] = val.strip()
+
+    # Update keys
+    updated = []
+    if request.runpod_api_key is not None:
+        existing["RUNPOD_API_KEY"] = request.runpod_api_key
+        os.environ["RUNPOD_API_KEY"] = request.runpod_api_key
+        updated.append("RUNPOD_API_KEY")
+
+    if request.wavespeed_api_key is not None:
+        existing["WAVESPEED_API_KEY"] = request.wavespeed_api_key
+        os.environ["WAVESPEED_API_KEY"] = request.wavespeed_api_key
+        updated.append("WAVESPEED_API_KEY")
+
+    # Write back
+    with open(env_path, "w") as f:
+        for key, val in existing.items():
+            f.write(f"{key}={val}\n")
+
+    return {
+        "status": "updated",
+        "updated_keys": updated,
+        "message": "API keys updated. Restart the server to fully apply changes."
+    }

src/content_engine/api/routes_training.py

@@ -0,0 +1,269 @@
+"""Training API routes — LoRA model training management."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
+
+from content_engine.services.lora_trainer import LoRATrainer, TrainingConfig
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/training", tags=["training"])
+
+_trainer: LoRATrainer | None = None
+_runpod_trainer = None  # RunPodTrainer | None
+
+
+def init_routes(trainer: LoRATrainer, runpod_trainer=None):
+    global _trainer, _runpod_trainer
+    _trainer = trainer
+    _runpod_trainer = runpod_trainer
+
+
+@router.get("/status")
+async def training_status():
+    """Check if training infrastructure is ready."""
+    if _trainer is None:
+        return {"ready": False, "sd_scripts_installed": False, "runpod_available": False}
+    return {
+        "ready": True,
+        "sd_scripts_installed": _trainer.sd_scripts_installed,
+        "runpod_available": _runpod_trainer is not None and _runpod_trainer.available,
+    }
+
+
+@router.get("/models")
+async def list_training_models():
+    """List available base models for LoRA training with their recommended parameters."""
+    if _runpod_trainer is None:
+        return {"models": {}, "default": "flux2_dev"}
+
+    models = _runpod_trainer.list_training_models()
+    return {
+        "models": models,
+        "default": "flux2_dev",  # FLUX 2 recommended for realistic person
+    }
+
+
+@router.get("/gpu-options")
+async def list_gpu_options():
+    """List available RunPod GPU types."""
+    if _runpod_trainer is None:
+        return {"gpus": {}}
+    return {"gpus": _runpod_trainer.list_gpu_options()}
+
+
+@router.post("/install")
+async def install_sd_scripts():
+    """Install Kohya sd-scripts for LoRA training."""
+    if _trainer is None:
+        raise HTTPException(503, "Trainer not initialized")
+    try:
+        msg = await _trainer.install_sd_scripts()
+        return {"status": "ok", "message": msg}
+    except Exception as e:
+        raise HTTPException(500, f"Installation failed: {e}")
+
+
+@router.post("/start")
+async def start_training(
+    images: list[UploadFile] = File(...),
+    name: str = Form(...),
+    trigger_word: str = Form(""),
+    captions_json: str = Form("{}"),
+    base_model: str = Form("flux2_dev"),  # Model registry key (flux2_dev, sd15_realistic, sdxl_base)
+    resolution: int | None = Form(None),  # None = use model default
+    num_epochs: int = Form(10),
+    max_train_steps: int | None = Form(None),  # If set, overrides epochs
+    learning_rate: float | None = Form(None),  # None = use model default
+    network_rank: int | None = Form(None),  # None = use model default
+    network_alpha: int | None = Form(None),  # None = use model default
+    optimizer: str | None = Form(None),  # None = use model default
+    train_batch_size: int = Form(1),
+    save_every_n_epochs: int = Form(2),
+    backend: str = Form("runpod"),  # Default to runpod for cloud training
+    gpu_type: str = Form("NVIDIA GeForce RTX 4090"),
+):
+    """Start a LoRA training job (local or RunPod cloud).
+
+    Parameters like resolution, learning_rate, network_rank will use model
+    registry defaults if not specified. Use base_model to select the model type.
+    """
+    import json
+
+    if len(images) < 5:
+        raise HTTPException(400, "Need at least 5 training images for reasonable results")
+
+    # Parse captions
+    try:
+        captions = json.loads(captions_json) if captions_json else {}
+    except json.JSONDecodeError:
+        captions = {}
+
+    # Save uploaded images to temp directory
+    import uuid
+    from content_engine.config import settings
+    upload_dir = settings.paths.data_dir / "training_uploads" / str(uuid.uuid4())[:8]
+    upload_dir.mkdir(parents=True, exist_ok=True)
+
+    image_paths = []
+    for img in images:
+        file_path = upload_dir / img.filename
+        content = await img.read()
+        file_path.write_bytes(content)
+        image_paths.append(str(file_path))
+
+        # Write caption .txt file alongside the image
+        caption_text = captions.get(img.filename, trigger_word or "")
+        caption_path = file_path.with_suffix(".txt")
+        caption_path.write_text(caption_text, encoding="utf-8")
+        logger.info("Saved caption for %s: %s", img.filename, caption_text[:80])
+
+    # Route to RunPod cloud trainer
+    if backend == "runpod":
+        if _runpod_trainer is None:
+            raise HTTPException(503, "RunPod not configured — set RUNPOD_API_KEY in .env")
+
+        # Validate model exists
+        model_cfg = _runpod_trainer.get_model_config(base_model)
+        if not model_cfg:
+            available = list(_runpod_trainer.list_training_models().keys())
+            raise HTTPException(400, f"Unknown base model: {base_model}. Available: {available}")
+
+        job_id = await _runpod_trainer.start_training(
+            name=name,
+            image_paths=image_paths,
+            trigger_word=trigger_word,
+            base_model=base_model,
+            resolution=resolution,
+            num_epochs=num_epochs,
+            max_train_steps=max_train_steps,
+            learning_rate=learning_rate,
+            network_rank=network_rank,
+            network_alpha=network_alpha,
+            optimizer=optimizer,
+            save_every_n_epochs=save_every_n_epochs,
+            gpu_type=gpu_type,
+        )
+        job = _runpod_trainer.get_job(job_id)
+        return {
+            "job_id": job_id,
+            "status": job.status if job else "unknown",
+            "name": name,
+            "backend": "runpod",
+            "base_model": base_model,
+            "model_type": model_cfg.get("model_type", "unknown"),
+        }
+
+    # Local training (uses local GPU with Kohya sd-scripts)
+    if _trainer is None:
+        raise HTTPException(503, "Trainer not initialized")
+
+    # For local training, use model registry defaults if available
+    model_cfg = {}
+    if _runpod_trainer:
+        model_cfg = _runpod_trainer.get_model_config(base_model) or {}
+
+    # Resolve local model path
+    local_model_path = model_cfg.get("local_path") if model_cfg else None
+    if not local_model_path:
+        # Fall back to default local path
+        local_model_path = str(settings.paths.checkpoint_dir / "realisticVisionV51_v51VAE.safetensors")
+
+    config = TrainingConfig(
+        name=name,
+        trigger_word=trigger_word,
+        base_model=local_model_path,
+        resolution=resolution or model_cfg.get("resolution", 512),
+        num_epochs=num_epochs,
+        learning_rate=learning_rate or model_cfg.get("learning_rate", 1e-4),
+        network_rank=network_rank or model_cfg.get("network_rank", 32),
+        network_alpha=network_alpha or model_cfg.get("network_alpha", 16),
+        optimizer=optimizer or model_cfg.get("optimizer", "AdamW8bit"),
+        train_batch_size=train_batch_size,
+        save_every_n_epochs=save_every_n_epochs,
+    )
+
+    job_id = await _trainer.start_training(config, image_paths)
+    job = _trainer.get_job(job_id)
+
+    return {
+        "job_id": job_id,
+        "status": job.status if job else "unknown",
+        "name": name,
+        "backend": "local",
+        "base_model": base_model,
+    }
+
+
+@router.get("/jobs")
+async def list_training_jobs():
+    """List all training jobs (local + cloud)."""
+    jobs = []
+    if _trainer:
+        for j in _trainer.list_jobs():
+            jobs.append({
+                "id": j.id, "name": j.name, "status": j.status,
+                "progress": round(j.progress, 3),
+                "current_epoch": j.current_epoch, "total_epochs": j.total_epochs,
+                "current_step": j.current_step, "total_steps": j.total_steps,
+                "loss": j.loss, "started_at": j.started_at,
+                "completed_at": j.completed_at, "output_path": j.output_path,
+                "error": j.error, "backend": "local",
+            })
+    if _runpod_trainer:
+        for j in _runpod_trainer.list_jobs():
+            jobs.append({
+                "id": j.id, "name": j.name, "status": j.status,
+                "progress": round(j.progress, 3),
+                "current_epoch": j.current_epoch, "total_epochs": j.total_epochs,
+                "current_step": j.current_step, "total_steps": j.total_steps,
+                "loss": j.loss, "started_at": j.started_at,
+                "completed_at": j.completed_at, "output_path": j.output_path,
+                "error": j.error, "backend": "runpod",
+                "base_model": j.base_model, "model_type": j.model_type,
+            })
+    return jobs
+
+
+@router.get("/jobs/{job_id}")
+async def get_training_job(job_id: str):
+    """Get details of a specific training job including logs."""
+    if _trainer is None:
+        raise HTTPException(503, "Trainer not initialized")
+    job = _trainer.get_job(job_id)
+    if job is None:
+        raise HTTPException(404, f"Training job not found: {job_id}")
+    return {
+        "id": job.id,
+        "name": job.name,
+        "status": job.status,
+        "progress": round(job.progress, 3),
+        "current_epoch": job.current_epoch,
+        "total_epochs": job.total_epochs,
+        "current_step": job.current_step,
+        "total_steps": job.total_steps,
+        "loss": job.loss,
+        "started_at": job.started_at,
+        "completed_at": job.completed_at,
+        "output_path": job.output_path,
+        "error": job.error,
+        "log_lines": job.log_lines[-50:],
+    }
+
+
+@router.post("/jobs/{job_id}/cancel")
+async def cancel_training_job(job_id: str):
+    """Cancel a running training job (local or cloud)."""
+    if _runpod_trainer and _runpod_trainer.get_job(job_id):
+        cancelled = await _runpod_trainer.cancel_job(job_id)
+        if cancelled:
+            return {"status": "cancelled", "job_id": job_id}
+    if _trainer:
+        cancelled = await _trainer.cancel_job(job_id)
+        if cancelled:
+            return {"status": "cancelled", "job_id": job_id}
+    raise HTTPException(404, "Job not found or not running")

src/content_engine/api/routes_ui.py

@@ -0,0 +1,23 @@
+"""Web UI route — serves the single-page dashboard."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter
+from fastapi.responses import HTMLResponse, Response
+
+router = APIRouter(tags=["ui"])
+
+UI_HTML_PATH = Path(__file__).parent / "ui.html"
+
+
+@router.get("/", response_class=HTMLResponse)
+async def dashboard():
+    """Serve the main dashboard UI."""
+    content = UI_HTML_PATH.read_text(encoding="utf-8")
+    return Response(
+        content=content,
+        media_type="text/html",
+        headers={"Cache-Control": "no-cache, no-store, must-revalidate"},
+    )

src/content_engine/api/routes_video.py

@@ -0,0 +1,309 @@
+"""Video generation routes — WAN 2.2 img2video on RunPod pod."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import time
+import uuid
+from pathlib import Path
+
+import runpod
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/video", tags=["video"])
+
+# Video jobs tracking
+_video_jobs: dict[str, dict] = {}
+
+# Pod state is shared from routes_pod
+def _get_pod_state():
+    from content_engine.api.routes_pod import _pod_state
+    return _pod_state
+
+
+class VideoGenerateRequest(BaseModel):
+    prompt: str
+    negative_prompt: str = ""
+    num_frames: int = 81  # ~3 seconds at 24fps
+    fps: int = 24
+    seed: int = -1
+
+
+@router.post("/generate")
+async def generate_video(
+    image: UploadFile = File(...),
+    prompt: str = Form(...),
+    negative_prompt: str = Form(""),
+    num_frames: int = Form(81),
+    fps: int = Form(24),
+    seed: int = Form(-1),
+):
+    """Generate a video from an image using WAN 2.2 I2V on the RunPod pod."""
+    import httpx
+    import random
+    import base64
+
+    pod_state = _get_pod_state()
+
+    if pod_state["status"] != "running":
+        raise HTTPException(400, "Pod not running - start it first in Status page")
+
+    job_id = str(uuid.uuid4())[:8]
+    seed = seed if seed >= 0 else random.randint(0, 2**32 - 1)
+
+    # Read the image
+    image_bytes = await image.read()
+    image_b64 = base64.b64encode(image_bytes).decode("utf-8")
+
+    # Build ComfyUI workflow for WAN 2.2 I2V
+    workflow = _build_wan_i2v_workflow(
+        image_b64=image_b64,
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        num_frames=num_frames,
+        fps=fps,
+        seed=seed,
+    )
+
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            # First upload the image to ComfyUI
+            upload_url = f"http://{pod_state['ip']}:{pod_state['port']}/upload/image"
+            files = {"image": (f"input_{job_id}.png", image_bytes, "image/png")}
+            upload_resp = await client.post(upload_url, files=files)
+
+            if upload_resp.status_code != 200:
+                raise HTTPException(500, "Failed to upload image to pod")
+
+            upload_data = upload_resp.json()
+            uploaded_filename = upload_data.get("name", f"input_{job_id}.png")
+
+            # Update workflow with uploaded filename
+            workflow = _build_wan_i2v_workflow(
+                uploaded_filename=uploaded_filename,
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                num_frames=num_frames,
+                fps=fps,
+                seed=seed,
+            )
+
+            # Submit workflow
+            url = f"http://{pod_state['ip']}:{pod_state['port']}/prompt"
+            resp = await client.post(url, json={"prompt": workflow})
+            resp.raise_for_status()
+
+            data = resp.json()
+            prompt_id = data["prompt_id"]
+
+            _video_jobs[job_id] = {
+                "prompt_id": prompt_id,
+                "status": "running",
+                "seed": seed,
+                "started_at": time.time(),
+                "num_frames": num_frames,
+                "fps": fps,
+            }
+
+            logger.info("Video generation started: %s -> %s", job_id, prompt_id)
+
+            # Start background task to poll for completion
+            asyncio.create_task(_poll_video_job(job_id, prompt_id))
+
+            return {
+                "job_id": job_id,
+                "status": "running",
+                "seed": seed,
+                "estimated_time": f"~{num_frames * 2} seconds",
+            }
+
+    except httpx.HTTPError as e:
+        logger.error("Video generation failed: %s", e)
+        raise HTTPException(500, f"Generation failed: {e}")
+
+
+async def _poll_video_job(job_id: str, prompt_id: str):
+    """Poll ComfyUI for video job completion."""
+    import httpx
+
+    pod_state = _get_pod_state()
+    start = time.time()
+    timeout = 600  # 10 minutes for video
+
+    async with httpx.AsyncClient(timeout=60) as client:
+        while time.time() - start < timeout:
+            try:
+                url = f"http://{pod_state['ip']}:{pod_state['port']}/history/{prompt_id}"
+                resp = await client.get(url)
+
+                if resp.status_code == 200:
+                    data = resp.json()
+                    if prompt_id in data:
+                        outputs = data[prompt_id].get("outputs", {})
+
+                        # Find video output (SaveAnimatedWEBP or VHS_VideoCombine)
+                        for node_id, node_output in outputs.items():
+                            # Check for gifs/videos
+                            if "gifs" in node_output:
+                                video_info = node_output["gifs"][0]
+                                await _download_video(client, job_id, video_info, pod_state)
+                                return
+                            # Check for images (animated)
+                            if "images" in node_output:
+                                img_info = node_output["images"][0]
+                                if img_info.get("type") == "output":
+                                    await _download_video(client, job_id, img_info, pod_state)
+                                    return
+
+            except Exception as e:
+                logger.debug("Polling video job: %s", e)
+
+            await asyncio.sleep(3)
+
+    _video_jobs[job_id]["status"] = "failed"
+    _video_jobs[job_id]["error"] = "Timeout waiting for video generation"
+    logger.error("Video generation timed out: %s", job_id)
+
+
+async def _download_video(client, job_id: str, video_info: dict, pod_state: dict):
+    """Download the generated video from ComfyUI."""
+    filename = video_info.get("filename")
+    subfolder = video_info.get("subfolder", "")
+    file_type = video_info.get("type", "output")
+
+    # Download video
+    view_url = f"http://{pod_state['ip']}:{pod_state['port']}/view"
+    params = {"filename": filename, "type": file_type}
+    if subfolder:
+        params["subfolder"] = subfolder
+
+    video_resp = await client.get(view_url, params=params)
+
+    if video_resp.status_code == 200:
+        # Save to local output directory
+        from content_engine.config import settings
+        output_dir = settings.paths.output_dir / "videos"
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Determine extension
+        ext = Path(filename).suffix or ".webp"
+        local_path = output_dir / f"video_{job_id}{ext}"
+        local_path.write_bytes(video_resp.content)
+
+        _video_jobs[job_id]["status"] = "completed"
+        _video_jobs[job_id]["output_path"] = str(local_path)
+        _video_jobs[job_id]["completed_at"] = time.time()
+        _video_jobs[job_id]["filename"] = local_path.name
+
+        logger.info("Video saved: %s", local_path)
+    else:
+        _video_jobs[job_id]["status"] = "failed"
+        _video_jobs[job_id]["error"] = "Failed to download video"
+
+
+@router.get("/jobs")
+async def list_video_jobs():
+    """List all video generation jobs."""
+    return list(_video_jobs.values())
+
+
+@router.get("/jobs/{job_id}")
+async def get_video_job(job_id: str):
+    """Get status of a video generation job."""
+    job = _video_jobs.get(job_id)
+    if not job:
+        raise HTTPException(404, "Job not found")
+    return job
+
+
+@router.get("/{filename}")
+async def get_video_file(filename: str):
+    """Serve a generated video file."""
+    from fastapi.responses import FileResponse
+    from content_engine.config import settings
+
+    video_path = settings.paths.output_dir / "videos" / filename
+    if not video_path.exists():
+        raise HTTPException(404, "Video not found")
+
+    media_type = "video/webm" if filename.endswith(".webm") else "image/webp"
+    return FileResponse(video_path, media_type=media_type)
+
+
+def _build_wan_i2v_workflow(
+    uploaded_filename: str = None,
+    image_b64: str = None,
+    prompt: str = "",
+    negative_prompt: str = "",
+    num_frames: int = 81,
+    fps: int = 24,
+    seed: int = -1,
+) -> dict:
+    """Build ComfyUI workflow for WAN 2.2 Image-to-Video."""
+
+    # WAN 2.2 I2V workflow
+    # This assumes the WAN 2.2 nodes are installed on the pod
+    workflow = {
+        # Load the input image
+        "1": {
+            "class_type": "LoadImage",
+            "inputs": {
+                "image": uploaded_filename or "input.png",
+            },
+        },
+        # WAN 2.2 model loader
+        "2": {
+            "class_type": "DownloadAndLoadWanModel",
+            "inputs": {
+                "model": "Wan2.2-I2V-14B-480P",
+            },
+        },
+        # Text encoder
+        "3": {
+            "class_type": "WanTextEncode",
+            "inputs": {
+                "prompt": prompt,
+                "negative_prompt": negative_prompt,
+                "wan_model": ["2", 0],
+            },
+        },
+        # Image-to-Video generation
+        "4": {
+            "class_type": "WanImageToVideo",
+            "inputs": {
+                "image": ["1", 0],
+                "wan_model": ["2", 0],
+                "conditioning": ["3", 0],
+                "num_frames": num_frames,
+                "seed": seed,
+                "steps": 30,
+                "cfg": 5.0,
+            },
+        },
+        # Decode to frames
+        "5": {
+            "class_type": "WanDecode",
+            "inputs": {
+                "samples": ["4", 0],
+                "wan_model": ["2", 0],
+            },
+        },
+        # Save as animated WEBP
+        "6": {
+            "class_type": "SaveAnimatedWEBP",
+            "inputs": {
+                "images": ["5", 0],
+                "filename_prefix": "wan_video",
+                "fps": fps,
+                "lossless": False,
+                "quality": 85,
+            },
+        },
+    }
+
+    return workflow

src/content_engine/config.py

@@ -0,0 +1,93 @@
+"""Configuration loader using Pydantic Settings."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings
+
+# Detect if running on Hugging Face Spaces
+IS_HF_SPACES = os.environ.get("HF_SPACES") == "1" or os.environ.get("SPACE_ID") is not None
+
+# Base paths - use environment variables or defaults
+if IS_HF_SPACES:
+    BASE_OUTPUT_DIR = Path(os.environ.get("OUTPUT_DIR", "/app/data/output"))
+    BASE_DATA_DIR = Path(os.environ.get("DATA_DIR", "/app/data"))
+    BASE_DB_PATH = os.environ.get("DB_PATH", "/app/data/db/content_engine.db")
+else:
+    BASE_OUTPUT_DIR = Path("D:/AI automation/output")
+    BASE_DATA_DIR = Path("D:/AI automation/data")
+    BASE_DB_PATH = "D:/AI automation/data/catalog.db"
+
+
+class ComfyUIConfig(BaseModel):
+    url: str = "http://127.0.0.1:8188"
+    max_local_queue_depth: int = 3
+    min_vram_gb: float = 2.0
+
+
+class PathsConfig(BaseModel):
+    output_dir: Path = BASE_OUTPUT_DIR
+    data_dir: Path = BASE_DATA_DIR
+    lora_dir: Path = Path("D:/ComfyUI/Models/Lora") if not IS_HF_SPACES else Path("/app/data/loras")
+    checkpoint_dir: Path = Path("D:/ComfyUI/Models/StableDiffusion") if not IS_HF_SPACES else Path("/app/data/models")
+
+
+class DatabaseConfig(BaseModel):
+    url: str = f"sqlite+aiosqlite:///{BASE_DB_PATH}"
+    jobs_url: str = f"sqlite+aiosqlite:///{BASE_DATA_DIR}/jobs.db"
+
+
+class GenerationConfig(BaseModel):
+    default_checkpoint: str = "realisticVisionV51_v51VAE.safetensors"
+    default_steps: int = 28
+    default_cfg: float = 7.0
+    default_sampler: str = "dpmpp_2m"
+    default_scheduler: str = "karras"
+    default_width: int = 832
+    default_height: int = 1216
+
+
+class SchedulingConfig(BaseModel):
+    posts_per_day: int = 3
+    peak_hours: list[int] = Field(default_factory=lambda: [10, 14, 20])
+    sfw_ratio: float = 0.4
+
+
+class CloudProviderEntry(BaseModel):
+    name: str
+    api_key: str = ""
+    priority: int = 1
+
+
+class Settings(BaseSettings):
+    comfyui: ComfyUIConfig = Field(default_factory=ComfyUIConfig)
+    paths: PathsConfig = Field(default_factory=PathsConfig)
+    database: DatabaseConfig = Field(default_factory=DatabaseConfig)
+    generation: GenerationConfig = Field(default_factory=GenerationConfig)
+    scheduling: SchedulingConfig = Field(default_factory=SchedulingConfig)
+    cloud_providers: list[CloudProviderEntry] = Field(default_factory=list)
+
+
+def load_settings(config_path: Path | None = None) -> Settings:
+    """Load settings from YAML config file, with env var overrides."""
+    if config_path is None:
+        if IS_HF_SPACES:
+            config_path = Path("/app/config/settings.yaml")
+        else:
+            config_path = Path("D:/AI automation/content_engine/config/settings.yaml")
+
+    data: dict[str, Any] = {}
+    if config_path.exists():
+        with open(config_path) as f:
+            data = yaml.safe_load(f) or {}
+
+    return Settings(**data)
+
+
+# Global singleton — initialized on import
+settings = load_settings()

src/content_engine/main.py

@@ -0,0 +1,213 @@
+"""Content Engine — FastAPI application entry point.
+
+Run with:
+    cd "D:\AI automation\content_engine"
+    uvicorn content_engine.main:app --host 0.0.0.0 --port 8000 --reload
+
+Or:
+    python -m content_engine.main
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+import yaml
+from dotenv import load_dotenv
+from fastapi import FastAPI
+
+from content_engine.config import settings
+from content_engine.models.database import init_db
+from content_engine.services.catalog import CatalogService
+from content_engine.services.comfyui_client import ComfyUIClient
+from content_engine.services.template_engine import TemplateEngine
+from content_engine.services.variation_engine import CharacterProfile, VariationEngine
+from content_engine.services.workflow_builder import WorkflowBuilder
+from content_engine.workers.local_worker import LocalWorker
+
+from content_engine.api import routes_catalog, routes_generation, routes_pod, routes_system, routes_training, routes_ui, routes_video
+
+# Load .env file for API keys
+import os
+IS_HF_SPACES = os.environ.get("HF_SPACES") == "1" or os.environ.get("SPACE_ID") is not None
+if IS_HF_SPACES:
+    load_dotenv(Path("/app/.env"))
+else:
+    load_dotenv(Path("D:/AI automation/content_engine/.env"))
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# Service instances (created at startup)
+comfyui_client: ComfyUIClient | None = None
+
+
+def load_character_profiles() -> dict[str, CharacterProfile]:
+    """Load all character YAML profiles from config/characters/."""
+    if IS_HF_SPACES:
+        characters_dir = Path("/app/config/characters")
+    else:
+        characters_dir = Path("D:/AI automation/content_engine/config/characters")
+    profiles: dict[str, CharacterProfile] = {}
+
+    if not characters_dir.exists():
+        logger.warning("Characters directory not found: %s", characters_dir)
+        return profiles
+
+    for path in characters_dir.glob("*.yaml"):
+        try:
+            with open(path) as f:
+                data = yaml.safe_load(f)
+            profile = CharacterProfile(
+                id=data["id"],
+                name=data.get("name", data["id"]),
+                trigger_word=data["trigger_word"],
+                lora_filename=data["lora_filename"],
+                lora_strength=data.get("lora_strength", 0.85),
+                default_checkpoint=data.get("default_checkpoint"),
+                style_loras=data.get("style_loras", []),
+                description=data.get("description", ""),
+                physical_traits=data.get("physical_traits", {}),
+            )
+            profiles[profile.id] = profile
+            logger.info("Loaded character: %s (%s)", profile.name, profile.id)
+        except Exception:
+            logger.error("Failed to load character %s", path, exc_info=True)
+
+    return profiles
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Startup and shutdown lifecycle."""
+    global comfyui_client
+
+    logger.info("Starting Content Engine...")
+
+    # Initialize database
+    await init_db()
+    logger.info("Database initialized")
+
+    # Create service instances
+    comfyui_client = ComfyUIClient(settings.comfyui.url)
+    workflow_builder = WorkflowBuilder()
+    template_engine = TemplateEngine()
+    template_engine.load_all()
+    catalog = CatalogService()
+    character_profiles = load_character_profiles()
+    variation_engine = VariationEngine(template_engine)
+
+    local_worker = LocalWorker(
+        comfyui_client=comfyui_client,
+        workflow_builder=workflow_builder,
+        template_engine=template_engine,
+        catalog=catalog,
+    )
+
+    # Check ComfyUI connection
+    if await comfyui_client.is_available():
+        logger.info("ComfyUI connected at %s", settings.comfyui.url)
+    else:
+        logger.warning(
+            "ComfyUI not available at %s — generation will fail until connected",
+            settings.comfyui.url,
+        )
+
+    # Initialize WaveSpeed cloud provider if API key is set
+    wavespeed_provider = None
+    wavespeed_key = os.environ.get("WAVESPEED_API_KEY")
+    if wavespeed_key:
+        from content_engine.services.cloud_providers.wavespeed_provider import WaveSpeedProvider
+        wavespeed_provider = WaveSpeedProvider(api_key=wavespeed_key)
+        logger.info("WaveSpeed cloud provider initialized (NanoBanana, SeeDream)")
+    else:
+        logger.info("WaveSpeed not configured — cloud generation disabled")
+
+    # Initialize route dependencies
+    routes_generation.init_routes(
+        local_worker, template_engine, variation_engine, character_profiles,
+        wavespeed_provider=wavespeed_provider, catalog=catalog,
+        comfyui_client=comfyui_client,
+    )
+    routes_catalog.init_routes(catalog)
+    routes_system.init_routes(comfyui_client, catalog, template_engine, character_profiles)
+
+    # Initialize LoRA trainer (local)
+    from content_engine.services.lora_trainer import LoRATrainer
+    lora_trainer = LoRATrainer()
+    logger.info("LoRA trainer initialized (sd-scripts %s)",
+                "ready" if lora_trainer.sd_scripts_installed else "not installed — install via UI")
+
+    # Initialize RunPod cloud trainer if API key is set
+    runpod_trainer = None
+    runpod_provider = None
+    runpod_key = os.environ.get("RUNPOD_API_KEY")
+    runpod_endpoint_id = os.environ.get("RUNPOD_ENDPOINT_ID")
+
+    if runpod_key:
+        from content_engine.services.runpod_trainer import RunPodTrainer
+        runpod_trainer = RunPodTrainer(api_key=runpod_key)
+        logger.info("RunPod cloud trainer initialized — cloud LoRA training available")
+
+        # Initialize RunPod generation provider if endpoint ID is set
+        if runpod_endpoint_id:
+            from content_engine.services.cloud_providers.runpod_provider import RunPodProvider
+            runpod_provider = RunPodProvider(api_key=runpod_key, endpoint_id=runpod_endpoint_id)
+            logger.info("RunPod generation provider initialized (endpoint: %s)", runpod_endpoint_id)
+        else:
+            logger.info("RunPod endpoint not configured — set RUNPOD_ENDPOINT_ID for cloud generation")
+    else:
+        logger.info("RunPod not configured — set RUNPOD_API_KEY for cloud training/generation")
+
+    routes_training.init_routes(lora_trainer, runpod_trainer=runpod_trainer)
+
+    # Update generation routes with RunPod provider
+    routes_generation.set_runpod_provider(runpod_provider)
+
+    logger.info(
+        "Content Engine ready — %d templates, %d characters",
+        len(template_engine.list_templates()),
+        len(character_profiles),
+    )
+
+    yield
+
+    # Shutdown
+    if comfyui_client:
+        await comfyui_client.close()
+    logger.info("Content Engine stopped")
+
+
+# Create the FastAPI app
+app = FastAPI(
+    title="Content Engine",
+    description="Automated content generation system using ComfyUI",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+# Register route modules
+app.include_router(routes_ui.router)  # UI at / (must be first)
+app.include_router(routes_generation.router)
+app.include_router(routes_catalog.router)
+app.include_router(routes_system.router)
+app.include_router(routes_training.router)
+app.include_router(routes_pod.router)
+app.include_router(routes_video.router)
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "content_engine.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+    )

src/content_engine/models/__init__.py

@@ -0,0 +1,31 @@
+"""Database models and Pydantic schemas."""
+
+from content_engine.models.database import (
+    Base,
+    Character,
+    GenerationJob,
+    Image,
+    ScheduledPost,
+)
+from content_engine.models.schemas import (
+    BatchRequest,
+    GenerationRequest,
+    GenerationResponse,
+    ImageResponse,
+    JobStatus,
+    SystemStatus,
+)
+
+__all__ = [
+    "Base",
+    "Character",
+    "GenerationJob",
+    "Image",
+    "ScheduledPost",
+    "BatchRequest",
+    "GenerationRequest",
+    "GenerationResponse",
+    "ImageResponse",
+    "JobStatus",
+    "SystemStatus",
+]

src/content_engine/models/database.py

@@ -0,0 +1,166 @@
+"""SQLAlchemy database models for the content catalog and job queue."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import (
+    Boolean,
+    DateTime,
+    Float,
+    Index,
+    Integer,
+    String,
+    Text,
+    func,
+)
+from sqlalchemy.ext.asyncio import AsyncAttrs, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+from content_engine.config import settings
+
+
+class Base(AsyncAttrs, DeclarativeBase):
+    pass
+
+
+class Character(Base):
+    __tablename__ = "characters"
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    name: Mapped[str] = mapped_column(String(128), nullable=False)
+    trigger_word: Mapped[str] = mapped_column(String(128), nullable=False)
+    lora_filename: Mapped[str] = mapped_column(String(256), nullable=False)
+    lora_strength: Mapped[float] = mapped_column(Float, default=0.85)
+    default_checkpoint: Mapped[str | None] = mapped_column(String(256))
+    description: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, server_default=func.now()
+    )
+
+
+class Image(Base):
+    __tablename__ = "images"
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True)
+    batch_id: Mapped[str | None] = mapped_column(String(36), index=True)
+    character_id: Mapped[str | None] = mapped_column(String(64), index=True)
+    template_id: Mapped[str | None] = mapped_column(String(128))
+    content_rating: Mapped[str] = mapped_column(String(8), index=True)  # sfw | nsfw
+
+    # Generation parameters
+    positive_prompt: Mapped[str | None] = mapped_column(Text)
+    negative_prompt: Mapped[str | None] = mapped_column(Text)
+    checkpoint: Mapped[str | None] = mapped_column(String(256))
+    loras_json: Mapped[str | None] = mapped_column(Text)  # JSON array
+    seed: Mapped[int | None] = mapped_column(Integer)
+    steps: Mapped[int | None] = mapped_column(Integer)
+    cfg: Mapped[float | None] = mapped_column(Float)
+    sampler: Mapped[str | None] = mapped_column(String(64))
+    scheduler: Mapped[str | None] = mapped_column(String(64))
+    width: Mapped[int | None] = mapped_column(Integer)
+    height: Mapped[int | None] = mapped_column(Integer)
+
+    # Searchable variation attributes
+    pose: Mapped[str | None] = mapped_column(String(128))
+    outfit: Mapped[str | None] = mapped_column(String(128))
+    emotion: Mapped[str | None] = mapped_column(String(128))
+    camera_angle: Mapped[str | None] = mapped_column(String(128))
+    lighting: Mapped[str | None] = mapped_column(String(128))
+    scene: Mapped[str | None] = mapped_column(String(128))
+
+    # File info
+    file_path: Mapped[str] = mapped_column(String(512), nullable=False)
+    file_hash: Mapped[str | None] = mapped_column(String(64))
+    file_size: Mapped[int | None] = mapped_column(Integer)
+    generation_backend: Mapped[str | None] = mapped_column(String(32))  # local | cloud
+    comfyui_prompt_id: Mapped[str | None] = mapped_column(String(36))
+    generation_time_seconds: Mapped[float | None] = mapped_column(Float)
+
+    # Quality and publishing
+    quality_score: Mapped[float | None] = mapped_column(Float)
+    is_approved: Mapped[bool] = mapped_column(Boolean, default=False)
+    is_published: Mapped[bool] = mapped_column(Boolean, default=False)
+    published_platform: Mapped[str | None] = mapped_column(String(64))
+    published_at: Mapped[datetime | None] = mapped_column(DateTime)
+    scheduled_at: Mapped[datetime | None] = mapped_column(DateTime)
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, server_default=func.now()
+    )
+
+    __table_args__ = (
+        Index("idx_images_approved", "is_approved", postgresql_where=(is_approved == True)),  # noqa: E712
+        Index(
+            "idx_images_unpublished",
+            "is_published",
+            "is_approved",
+        ),
+    )
+
+
+class GenerationJob(Base):
+    __tablename__ = "generation_jobs"
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True)
+    batch_id: Mapped[str | None] = mapped_column(String(36), index=True)
+    character_id: Mapped[str | None] = mapped_column(String(64))
+    template_id: Mapped[str | None] = mapped_column(String(128))
+    content_rating: Mapped[str | None] = mapped_column(String(8))
+    variables_json: Mapped[str | None] = mapped_column(Text)
+    workflow_json: Mapped[str | None] = mapped_column(Text)
+    backend: Mapped[str | None] = mapped_column(String(32))  # local | replicate | runpod
+    status: Mapped[str] = mapped_column(
+        String(16), default="pending", index=True
+    )  # pending | queued | running | completed | failed
+    comfyui_prompt_id: Mapped[str | None] = mapped_column(String(36))
+    cloud_job_id: Mapped[str | None] = mapped_column(String(128))
+    result_image_id: Mapped[str | None] = mapped_column(String(36))
+    error_message: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, server_default=func.now()
+    )
+    started_at: Mapped[datetime | None] = mapped_column(DateTime)
+    completed_at: Mapped[datetime | None] = mapped_column(DateTime)
+
+
+class ScheduledPost(Base):
+    __tablename__ = "scheduled_posts"
+
+    id: Mapped[str] = mapped_column(String(36), primary_key=True)
+    image_id: Mapped[str] = mapped_column(String(36), nullable=False)
+    platform: Mapped[str] = mapped_column(String(64), nullable=False)
+    scheduled_at: Mapped[datetime] = mapped_column(DateTime, nullable=False)
+    caption: Mapped[str | None] = mapped_column(Text)
+    is_teaser: Mapped[bool] = mapped_column(Boolean, default=False)
+    status: Mapped[str] = mapped_column(
+        String(16), default="pending"
+    )  # pending | published | failed | cancelled
+    published_at: Mapped[datetime | None] = mapped_column(DateTime)
+    error_message: Mapped[str | None] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, server_default=func.now()
+    )
+
+    __table_args__ = (
+        Index("idx_scheduled_pending", "status", "scheduled_at"),
+    )
+
+
+# --- Engine / Session factories ---
+
+_catalog_engine = create_async_engine(
+    settings.database.url,
+    echo=False,
+    connect_args={"check_same_thread": False},  # SQLite specific
+)
+
+catalog_session_factory = async_sessionmaker(
+    _catalog_engine, expire_on_commit=False
+)
+
+
+async def init_db() -> None:
+    """Create all tables. Call once at startup."""
+    async with _catalog_engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)

src/content_engine/models/schemas.py

@@ -0,0 +1,118 @@
+"""Pydantic request/response schemas for the API."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+# --- Request schemas ---
+
+
+class LoRASpec(BaseModel):
+    name: str
+    strength_model: float = 0.85
+    strength_clip: float = 0.85
+
+
+class GenerationRequest(BaseModel):
+    """Single image generation request."""
+
+    character_id: str | None = None
+    template_id: str | None = None
+    content_rating: str = "sfw"  # sfw | nsfw
+
+    # Direct prompt override (if not using template)
+    positive_prompt: str | None = None
+    negative_prompt: str | None = None
+
+    # Model configuration
+    checkpoint: str | None = None
+    loras: list[LoRASpec] = Field(default_factory=list)
+
+    # Sampler settings
+    seed: int | None = None
+    steps: int | None = None
+    cfg: float | None = None
+    sampler: str | None = None
+    scheduler: str | None = None
+    width: int | None = None
+    height: int | None = None
+
+    # Variation variables (for template rendering)
+    variables: dict[str, str] = Field(default_factory=dict)
+
+
+class BatchRequest(BaseModel):
+    """Batch generation request."""
+
+    character_id: str
+    template_id: str
+    content_rating: str = "sfw"
+    count: int = 10
+    variation_mode: str = "random"  # curated | random | exhaustive
+    pin: dict[str, str] = Field(default_factory=dict)
+    seed_strategy: str = "random"  # random | sequential | fixed
+
+
+# --- Response schemas ---
+
+
+class GenerationResponse(BaseModel):
+    job_id: str
+    batch_id: str | None = None
+    status: str
+    backend: str | None = None
+
+
+class JobStatus(BaseModel):
+    job_id: str
+    batch_id: str | None = None
+    status: str  # pending | queued | running | completed | failed
+    backend: str | None = None
+    progress: float | None = None  # 0.0 - 1.0
+    result_image_id: str | None = None
+    error_message: str | None = None
+    created_at: datetime | None = None
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+
+
+class ImageResponse(BaseModel):
+    id: str
+    character_id: str | None = None
+    template_id: str | None = None
+    content_rating: str
+    file_path: str
+    seed: int | None = None
+    pose: str | None = None
+    outfit: str | None = None
+    emotion: str | None = None
+    camera_angle: str | None = None
+    lighting: str | None = None
+    scene: str | None = None
+    quality_score: float | None = None
+    is_approved: bool
+    is_published: bool
+    created_at: datetime | None = None
+
+
+class SystemStatus(BaseModel):
+    comfyui_connected: bool
+    gpu_name: str | None = None
+    vram_total_gb: float | None = None
+    vram_free_gb: float | None = None
+    local_queue_depth: int = 0
+    cloud_available: bool = False
+    total_images: int = 0
+    pending_jobs: int = 0
+
+
+class BatchStatusResponse(BaseModel):
+    batch_id: str
+    total_jobs: int
+    completed: int
+    failed: int
+    pending: int
+    running: int

src/content_engine/services/__init__.py

@@ -0,0 +1 @@
+"""Services layer for the content engine."""