Initial commit

.gitignore

@@ -0,0 +1,16 @@
+.cache/
+.venv/
+logs/
+output/
+
+*.log
+git_add_*.txt
+git_add_output.log
+
+imageforge/.cache/
+imageforge/logs/
+imageforge/output/
+
+stable-diffusion-webui/models/
+stable-diffusion-webui/repositories/
+stable-diffusion-webui/tmp/

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "chat.tools.terminal.autoApprove": {
+        "&": true,
+        "npm run dev:web": true
+    }
+}

ARCHITECTURE_HUGGINGFACE.md

@@ -0,0 +1,245 @@
+# 🏗️ PixelForge Architektur mit HuggingFace Spaces
+
+## Übersicht
+
+PixelForge wird als **Orchestrator** fungieren, der externe AI-Services via REST API orchestriert. Die Heavy-Lifting (GPU-intensive Image Generation) läuft auf HuggingFace Spaces.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│            PixelForge Frontend (React/Vite)             │
+│                   http://127.0.0.1:5173                │
+└────────────────────┬────────────────────────────────────┘
+                     │
+                     │ HTTP Requests
+                     ↓
+┌─────────────────────────────────────────────────────────┐
+│          PixelForge Backend (FastAPI)                   │
+│           http://127.0.0.1:8008                        │
+│  ┌──────────────────────────────────────────────────┐  │
+│  │  Provider Factory & Job Manager                 │  │
+│  └────┬─────────────────────────────────────────────┘  │
+└────┼──────────────────────────────────────────────────────┘
+     │
+     ├─ Lokale Provider (CPU):
+     │  ├─ dummy: Dummy bilder
+     │  ├─ localai: LocalAI Engine
+     │  └─ diffusion: Stable Diffusion (lokal)
+     │
+     └─ Remote Provider (API/GPU):
+        ├─ zimageturbo: Cloud API (Colab/RunPod) [ÜBERGANGSLÖSUNG]
+        ├─ huggingface: HuggingFace Space API [ZUKÜNFTIG]
+        │  ├─ Heartsync/Adult Space (erwachsene Inhalte)
+        │  ├─ weitere HF Spaces...
+        │  └─ Authentifizierung via HF API Token
+        │
+        └─ a1111: AUTOMATIC1111 API (lokal falls vorhanden)
+```
+
+---
+
+## Phase 1: Aktuelle State (Übergangslösung)
+
+**Colab + Z-Image Turbo** als schneller Remote-Provider:
+- ✅ Funktioniert sofort
+- ⚠️ Session-basiert (max 12 Stunden)
+- ⚠️ Colab kann jeden Moment beenden
+- ✅ Kostenlos
+
+**Implementation**: `zimageturbo_provider.py` (HTTP API Wrapper)
+
+### Zu tun jetzt:
+1. Frontend testen (Modellauswahl wurde gefixt)
+2. Colab Notebook hochladen & API URL setzen
+3. Z-Image Turbo Provider testen
+
+---
+
+## Phase 2: HuggingFace Space Integration (Zukünftig)
+
+**Adult_repo** bleibt als eigenständige Einheit auf HuggingFace Spaces:
+
+```bash
+# Adult_repo läuft auf:
+https://huggingface.co/spaces/Heartsync/Adult
+# → Hat eigene GPU/Inference Engine
+# → Verfügbar 24/7 (solange Space online)
+```
+
+### Architektur:
+
+1. **Adult_repo auf HF Space** (remote)
+   - Gradio Interface (aber nicht für PixelForge relevant)
+   - Inference Endpoint für API-Calls
+   - Nutzt Z-Image Turbo Model intern
+
+2. **HuggingFace Space API Provider** (neu in PixelForge)
+   ```python
+   # Backend Provider
+   class HuggingFaceSpaceProvider(IImageProvider):
+       def __init__(self, space_name: str, token: str):
+           self.space_name = "Heartsync/Adult"  # oder andere Spaces
+           self.api_token = os.getenv("HF_API_TOKEN")
+           
+       def generate(self, request: ProviderRequest) -> ProviderResult:
+           # POST zu HF Inference API
+           # https://api-inference.huggingface.co/models/{space}
+           ...
+   ```
+
+3. **PixelForge kennt mehrere Spaces**:
+   - `heartsync/adult` → Erwachsene Inhalte
+   - `heartsync/anime` → Anime-Style
+   - `custom/space` → Beliebige andere Spaces
+
+---
+
+## Vergleich: Colab vs HuggingFace Space
+
+| Aspekt | Colab | HF Space | Lokal |
+|--------|-------|----------|-------|
+| **Setup** | Jupyter Notebook | Einmal deployen | Python Virtual Env |
+| **Kosten** | Kostenlos | Kostenlos (mit Limits) | Nur Hardware |
+| **Persistenz** | 12h max | 24/7 (solange online) | 24/7 |
+| **GPU** | T4/A100 (kostenlos) | Space-spezifisch | Deine Hardware |
+| **API-Zugriff** | über Ngrok-Tunnel | HF Inference API | localhost:PORT |
+| **Startzeit** | ~2 min (Kernel) | instant | instant |
+| **Geeignet für** | Schnelle Tests | Production | Development |
+
+---
+
+## Implementierungs-Roadmap
+
+### ✅ Heute (Phase 1)
+- [x] Frontend Model-Picker repariert
+- [x] Colab Notebook erstellt
+- [x] zimageturbo_provider.py ✓
+- [ ] Testen mit Colab
+
+### 📅 Später (Phase 2)
+- [ ] HuggingFaceSpaceProvider erstellen
+- [ ] HF API Token Authentication
+- [ ] Adult_repo auf HF Space deployen
+- [ ] Provider registrieren & testen
+- [ ] Colab durch HF Space ersetzen
+
+### 🎯 Langfristig (Phase 3)
+- [ ] Multi-Space Support (verschiedene Spaces wählen)
+- [ ] Space Health Monitoring
+- [ ] Fallback-Strategie (wenn Space down ist)
+- [ ] Queue Management für lange Jobs
+
+---
+
+## HuggingFace API Details (für später)
+
+### Space Deployment (Adult_repo)
+```bash
+# HF CLI installieren
+pip install huggingface-hub
+
+# Private Space erstellen (Adult content)
+huggingface-cli repo create --type space Adult_repo --private
+
+# Adult_repo hochladen
+git push huggingface main
+```
+
+### PixelForge Provider (HTTP API Call)
+```python
+import requests
+
+# HF Inference API Endpoint
+url = "https://api-inference.huggingface.co/models/Heartsync/Adult"
+
+payload = {
+    "inputs": "A beautiful sunset over mountains",
+}
+
+headers = {
+    "Authorization": f"Bearer {HF_API_TOKEN}"
+}
+
+response = requests.post(url, json=payload, headers=headers)
+image_data = response.content  # PIL Image bytes
+```
+
+### Alternative: Space API (wenn Gradio genutzt)
+```python
+# Falls Adult_repo Gradio API exponiert
+from gradio_client import Client
+
+client = Client("https://huggingface.co/spaces/Heartsync/Adult")
+result = client.predict(
+    prompt="A girl in a school uniform",
+    seed=42,
+    api_name="/predict"
+)
+```
+
+---
+
+## Umgebungsvariablen (Phase 2)
+
+```powershell
+# HuggingFace Integration
+$env:HF_API_TOKEN = "hf_xxxxxxxxxxxxxxxxxxxxx"
+$env:HF_SPACE_ADULT = "Heartsync/Adult"
+$env:HF_SPACE_DEFAULT = "Heartsync/Adult"
+$env:HF_REQUEST_TIMEOUT = "300"  # Sekunden
+
+# Colab (Phase 1 - temporär)
+$env:ZIMAGETURBO_API_URL = "https://abc123.ngrok.io"
+$env:ZIMAGETURBO_TIMEOUT = "300"
+```
+
+---
+
+## Adult_repo Struktur (vor Ort)
+
+```
+d:/VSC Codes/Bild/Adult_repo/
+├── app.py                 # Gradio Interface (wird auf HF Space laufen)
+├── requirements.txt       # Dependencies
+├── README.md
+└── .git                   # Git Repo
+```
+
+**Wichtig**: Adult_repo ist momentan nicht in PixelForge integriert!
+- Es läuft später als eigenständiger Service auf HF Space
+- PixelForge ruft es via HF API auf
+- Keine lokale Abhängigkeit → Clean Architecture ✨
+
+---
+
+## Nächste Schritte
+
+### Sofort (Phase 1):
+```powershell
+# 1. Frontend aktualisieren (Done ✓)
+# 2. Browser aktualisieren (F5)
+# 3. Modellauswahl testen
+# 4. Colab konfigurieren & testen
+```
+
+### Später (Phase 2):
+```powershell
+# 1. Adult_repo zu HF Space pushen
+# 2. HF API Token besorgen
+# 3. HuggingFaceSpaceProvider schreiben
+# 4. In Factory registrieren
+# 5. Testen & Colab deaktivieren
+```
+
+---
+
+## Fragen für Phase 2?
+
+- Welche anderen Spaces möchtest du anbinden?
+- Benötigst du Content Moderation (Safety Filter)?
+- Wie sollen lange Jobs (>5min) gehandhabt werden?
+- Fallback-Strategie wenn Space down ist?
+
+---
+
+**Status**: 🟢 Phase 1 bereitet sich vor
+**Phase 2 Start**: Nach Colab-Test & HF Space Deployment

Adult_repo/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Adult_repo/README.md

@@ -0,0 +1,13 @@
+---
+title: NSFW Uncensored Adult Image
+emoji: 📈
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: 6.0.2
+app_file: app.py
+pinned: false
+short_description: Based 'Z-IMAGE TURBO'
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Adult_repo/app.py

@@ -0,0 +1,207 @@
+import torch
+import spaces
+import gradio as gr
+from diffusers import DiffusionPipeline
+import diffusers
+import numpy as np
+import random
+
+# =========================================================
+# MODEL CONFIGURATION
+# =========================================================
+MAX_SEED = np.iinfo(np.int32).max
+
+# =========================================================
+# PROMPT EXAMPLES
+# =========================================================
+prompt_examples = [
+    "The shy college girl, with glasses and a tight plaid skirt, nervously approaches her professor",
+    "Her skirt rose a little higher with each gentle push, a soft blush of blush spreading across her cheeks as she felt the satisfying warmth of his breath on her cheek.",
+    "a girl in a school uniform having her skirt pulled up by a boy, and then being fucked",
+    "Moody mature anime scene of two lovers fuck under neon rain, sensual atmosphere",
+    "Moody mature anime scene of two lovers kissing under neon rain, sensual atmosphere",
+    "The girl sits on the boy's lap by the window, his hands resting on her waist. She is unbuttoning his shirt, her expression focused and intense.",
+    "A girl with long, black hair is sleeping on her desk in the classroom. Her skirt has ridden up, revealing her thighs, and a trail of drool escapes her slightly parted lips.",
+    "The waves rolled gently, a slow, sweet kiss of the lip, a slow, slow build of anticipation as their toes bumped gently – a slow, sweet kiss of the lip, a promise of more to come.",
+    "Her elegant silk gown swayed gracefully as she approached him, the delicate fabric brushing against her legs. A warm blush spread across her cheeks as she felt his breath on her face.",
+    "Her white blouse and light cotton skirt rose a little higher with each gentle push, a soft blush spreading across her cheeks as she felt the satisfying warmth of his breath on her cheek.",
+    "A woman in a business suit having her skirt lifted by a man, and then being sexually assaulted.",
+    "The older woman sits on the man's lap by the fireplace, his hands resting on her hips. She is unbuttoning his vest, her expression focused and intense. He takes control of the situation as she finishes unbuttoning his shirt, pushing her onto her back and begins to have sex with her.",
+    "There is a woman with long black hair. Her face features alluring eyes and full lips, with a slender figure adorned in black lace lingerie. She lies on the bed, loosening her lingerie strap with one hand while seductively glancing downward.",
+    "In a dimly lit room, the same woman teases with her dark, flowing hair, now covering her voluptuous breasts, while a black garter belt accentuates her thighs. She sits on the sofa, leaning back, lifting one leg to expose her most private areas through the sheer lingerie.",
+    "A woman with glasses, lying on the bed in just her bra, spreads her legs wide, revealing all! She wears a sultry expression, gazing directly at the viewer with her brown eyes, her short black hair cascading over the pillow. Her slim figure, accentuated by the lacy lingerie, exudes a seductive aura.",
+    "A soft focus on the girl's face, eyes closed, biting her lip, as her roommate performs oral pleasure, the experienced woman's hair cascading between her thighs.",
+    "A woman in a blue hanbok sits on a wooden floor, her legs folded beneath her, gazing out of a window, the sunlight highlighting the graceful lines of her clothing.",
+    "The couple, immersed in a wooden outdoor bath, share an intimate moment, her wet kimono clinging to her curves, his hands exploring her body beneath the water's surface.",
+    "A steamy shower scene, the twins embrace under the warm water, their soapy hands gliding over each other's curves, their passion intensifying as they explore uncharted territories.",
+    "The teacher, with a firm grip, pins the student against the blackboard, her skirt hiked up, exposing her delicate lace panties. Their heavy breathing echoes in the quiet room as they share an intense, intimate moment.",
+    "After hours, the girl sits on top of the teacher's lap, riding him on the classroom floor, her hair cascading over her face as she moves with increasing intensity, their bodies glistening with sweat.",
+    "In the dimly lit dorm room, the roommates lay entangled in a passionate embrace, their naked bodies glistening with sweat, as the experienced woman teaches her lover the art of kissing and touching.",
+    "The once-innocent student, now confident, takes charge, straddling her lover on the couch, their bare skin illuminated by the warm glow of the sunset through the window.",
+    "A close-up of the secretary's hand unzipping her boss's dress shirt, her fingers gently caressing his chest, their eyes locked in a heated embrace in the supply closet.",
+    "The secretary, in a tight pencil skirt and silk blouse, leans back on the boss's desk, her legs wrapped around his waist, her blouse unbuttoned, revealing her lace bra, as he passionately kisses her, his hands exploring her body.",
+    "On the living room couch, one twin sits astride her sister's lap, their lips locked in a passionate kiss, their hands tangled in each other's hair, unraveling a new level of intimacy.",
+    "In a dimly lit chamber, the dominant woman, dressed in a leather corset and thigh-high boots, stands tall, her hand gripping her submissive partner's hair, his eyes closed in submission as she instructs him to please her.",
+    "The dominant, in a sheer lace bodysuit, sits on a throne-like chair, her legs spread, as the submissive, on his knees, worships her with his tongue, his hands bound behind his back.",
+    "A traditional Japanese onsen, with steam rising, a young woman in a colorful kimono kneels on a tatami mat, her back to the viewer, as her male partner, also in a kimono, gently unties her obi, revealing her bare back.",
+    "In a serene outdoor setting, the woman, in a vibrant summer kimono, sits on a bench, her legs slightly spread, her partner kneeling before her, his hands gently caressing her exposed thigh.",
+]
+
+# =========================================================
+# LOAD PIPELINE
+# =========================================================
+print("Loading Z-Image-Turbo pipeline...")
+diffusers.utils.logging.set_verbosity_info()
+
+pipe = DiffusionPipeline.from_pretrained(
+    "Tongyi-MAI/Z-Image-Turbo",
+    torch_dtype=torch.bfloat16,
+    low_cpu_mem_usage=False,
+    attn_implementation="kernels-community/vllm-flash-attn3",
+)
+pipe.to("cuda")
+
+# =========================================================
+# RANDOM PROMPT FUNCTION
+# =========================================================
+def get_random_prompt():
+    return random.choice(prompt_examples)
+
+# =========================================================
+# IMAGE GENERATOR
+# =========================================================
+@spaces.GPU
+def generate_image(prompt, height, width, num_inference_steps, seed, randomize_seed, num_images):
+    if not prompt:
+        raise gr.Error("Please enter a prompt.")
+
+    if randomize_seed:
+        seed = torch.randint(0, 2**32 - 1, (1,)).item()
+
+    num_images = min(max(1, int(num_images)), 4)
+
+    generator = torch.Generator("cuda").manual_seed(int(seed))
+
+    result = pipe(
+        prompt=prompt,
+        height=int(height),
+        width=int(width),
+        num_inference_steps=int(num_inference_steps),
+        guidance_scale=0.0,
+        generator=generator,
+        max_sequence_length=1024,
+        num_images_per_prompt=num_images,
+        output_type="pil",
+    )
+
+    return result.images, seed
+
+# =========================================================
+# GRADIO UI
+# =========================================================
+with gr.Blocks() as demo:
+    
+    gr.HTML("""
+        <style>
+            .gradio-container {
+                background: linear-gradient(135deg, #fef9f3 0%, #f0e6fa 50%, #e6f0fa 100%) !important;
+            }
+            footer {display: none !important;}
+        </style>
+
+        <div style="text-align: center; margin-bottom: 20px;">
+            <h1 style="color: #6b5b7a; font-size: 2.2rem; font-weight: 700; margin-bottom: 0.3rem;">
+                🖼️ NSFW Uncensored Adult "Text to Image"
+            </h1>
+
+            <p style="color: #8b7b9b; font-size: 1rem;">
+                Powered by Z-Image-Turbo Model
+            </p>
+
+            <div style="margin-top: 12px; display: flex; justify-content: center; gap: 12px; flex-wrap: wrap;">
+                <a href="https://huggingface.co/spaces/Heartsync/FREE-NSFW-HUB" target="_blank">
+                    <img src="https://img.shields.io/static/v1?label=FREE&message=NSFW%20HUB&color=%230000ff&labelColor=%23800080&logo=huggingface&logoColor=white&style=for-the-badge" alt="badge">
+                </a>
+
+                <a href="https://www.humangen.ai" target="_blank">
+                    <img src="https://img.shields.io/static/v1?label=100%25%20FREE&message=AI%20Playground&color=%230000ff&labelColor=%23800080&logo=huggingface&logoColor=%23ffa500&style=for-the-badge" alt="badge">
+                </a>
+
+                <a href="https://huggingface.co/spaces/Heartsync/NSFW-Uncensored-photo" target="_blank">
+                    <img src="https://img.shields.io/static/v1?label=Text%20to%20Image%28Photo%29&message=NSFW%20Uncensored&color=%230000ff&labelColor=%23800080&logo=Huggingface&logoColor=%23ffa500&style=for-the-badge" alt="badge">
+                </a>
+
+                <a href="https://huggingface.co/spaces/Heartsync/NSFW-Uncensored-video2" target="_blank">
+                    <img src="https://img.shields.io/static/v1?label=Image%20to%20Video%282%29&message=NSFW%20Uncensored&color=%230000ff&labelColor=%23800080&logo=Huggingface&logoColor=%23ffa500&style=for-the-badge" alt="badge">
+                </a>
+
+                <a href="https://huggingface.co/spaces/Heartsync/adult" target="_blank">
+                    <img src="https://img.shields.io/static/v1?label=Text%20to%20Image%20to%20Video&message=ADULT&color=%23ff00ff&labelColor=%23000080&logo=Huggingface&logoColor=%23ffa500&style=for-the-badge" alt="badge">
+                </a>
+            </div>
+        </div>
+    """)
+
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            prompt_input = gr.Textbox(
+                label="✏️ Prompt",
+                placeholder="Describe the image you want to create...",
+                lines=3
+            )
+            
+            random_button = gr.Button("🎲 Random Prompt", variant="secondary")
+            
+            with gr.Row():
+                height_input = gr.Slider(512, 2048, 1024, step=64, label="Height")
+                width_input = gr.Slider(512, 2048, 1024, step=64, label="Width")
+            
+            num_images_input = gr.Slider(1, 4, 2, step=1, label="🖼️ Number of Images")
+
+            with gr.Accordion("⚙️ Options", open=False):
+                steps_slider = gr.Slider(
+                    minimum=1, 
+                    maximum=30, 
+                    step=1, 
+                    value=18, 
+                    label="Inference Steps"
+                )
+                seed_input = gr.Slider(
+                    label="Seed", 
+                    minimum=0, 
+                    maximum=MAX_SEED, 
+                    step=1, 
+                    value=42
+                )
+                randomize_seed_checkbox = gr.Checkbox(
+                    label="Randomize Seed", 
+                    value=True
+                )
+
+            generate_button = gr.Button(
+                "✨ Generate Image", 
+                variant="primary"
+            )
+
+        with gr.Column(scale=1):
+            output_gallery = gr.Gallery(
+                label="🎨 Generated Images",
+                height=450,
+                columns=2
+            )
+            used_seed_output = gr.Number(label="Seed Used", interactive=False)
+
+    random_button.click(
+        fn=get_random_prompt,
+        outputs=[prompt_input]
+    )
+
+    generate_button.click(
+        fn=generate_image,
+        inputs=[prompt_input, height_input, width_input, steps_slider, seed_input, randomize_seed_checkbox, num_images_input],
+        outputs=[output_gallery, used_seed_output],
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch()

Adult_repo/requirements.txt

@@ -0,0 +1,9 @@
+gradio
+git+https://github.com/huggingface/diffusers
+transformers
+kernels
+
+torch
+transformers
+accelerate
+spaces

FIXED_README.md

@@ -0,0 +1,87 @@
+# ImageForge - Fixed & Working!
+
+## ✓ Problem gelöst!
+
+Die Bildgenerierung funktioniert jetzt mit echten KI-Modellen! 
+
+### Was wurde behoben:
+
+1. **GPU-Aktivierung**: PyTorch mit CUDA 12.1 installiert - GPU wird jetzt verwendet!
+2. **Threading-Fehler**: Race Condition bei parallelen Jobs behoben
+3. **Modell-Download**: `segmind/tiny-sd` vollständig heruntergeladen (~1 GB)
+4. **urllib3-Problem**: Downgrade auf 1.26.20 (behob Import-Fehler bei diffusers)
+5. **Default Model**: API verwendet jetzt `localai` statt `dummy` als Standard
+
+### Wie starten:
+
+Doppelklick auf `START_IMAGEFORGE.bat` in `d:\VSC Codes\Bild\`
+
+Das startet:
+- Backend auf http://127.0.0.1:8008
+- Frontend auf http://127.0.0.1:5173
+
+Nach ~15-20 Sekunden ist das Programm bereit!
+
+### Erste Bildgenerierung:
+
+1. Browser öffnet sich automatisch bei http://127.0.0.1:5173
+2. Prompt eingeben (z.B. "a beautiful sunset over mountains")
+3. Auf "Generate" klicken
+4. Warten (~45-60 Sekunden für das erste Bild)
+5. **Ergebnis**: Echtes KI-generiertes Bild (>400 KB), KEIN weißes Dummy-Bild mehr!
+
+### Verwendetes Modell:
+
+- **segmind/tiny-sd** (Standard)
+  - Schnell: ~45-60 Sekunden pro Bild (512x512)
+  - Speicher: ~2 GB VRAM
+  - Qualität: Gut für schnelle Tests
+
+### Optional: Besseres Modell (in Zukunft):
+
+Die `runwayml/stable-diffusion-v1-5` Download wurde gestartet (~4 GB).
+Wenn vollständig heruntergeladen, kann das Modell in `backend/app/local_ai/engine.py` 
+umgestellt werden (Zeile 49):
+
+```python
+self.model_id = os.getenv("IMAGEFORGE_LOCALAI_MODEL", "runwayml/stable-diffusion-v1-5")
+```
+
+### Systemanforderungen (erfüllt):
+
+- ✓ Python 3.12.10 mit venv
+- ✓ PyTorch 2.5.1+cu121 (CUDA 12.1)
+- ✓ NVIDIA GeForce GTX 1050 (CUDA verfügbar)
+- ✓ diffusers 0.36.0
+- ✓ urllib3 1.26.20 (wichtig!)
+
+### Bekannte Einschränkungen:
+
+- Erste Generation pro Sitzung dauert länger (Modell laden: ~30 Sekunden)
+- tiny-sd erzeugt kleinere Bilder mit weniger Details als größere Modelle
+- GTX 1050 hat nur 2 GB VRAM - größere Modelle nicht möglich
+
+### Bei Problemen:
+
+Wenn wieder weiße Bilder erscheinen:
+
+1. Backend-Fenster prüfen auf Fehler
+2. Sicherstellen dass urllib3==1.26.20 installiert ist:
+   ```
+   d:\VSC Codes\Bild\.venv\Scripts\python.exe -m pip list | findstr urllib3
+   ```
+3. Falls 2.x: Downgrade durchführen:
+   ```
+   d:\VSC Codes\Bild\.venv\Scripts\python.exe -m pip install "urllib3<2.0" --force-reinstall
+   ```
+
+### Nächste Schritte (optional):
+
+1. **Qualität verbessern**: SD 1.5 Modell verwenden (sobald Download fertig)
+2. **Frontend anpassen**: UI-Elemente nach Wunsch ändern
+3. **Weitere Modelle**: Andere HuggingFace Modelle testen
+
+---
+
+**Status**: ✓ Funktioniert! Echte Bilder werden generiert!
+**Letzte Änderung**: 2026-02-19 22:20

START_IMAGEFORGE.bat

@@ -0,0 +1,43 @@
+@echo off
+echo ======================================
+echo   ImageForge Stack Startup
+echo ======================================
+echo.
+
+REM Set HuggingFace cache and environment variables
+set HF_HOME=d:/VSC Codes/Bild/.cache/hf
+set TRANSFORMERS_CACHE=d:/VSC Codes/Bild/.cache/hf
+
+cd /d "%~dp0imageforge"
+
+echo [1/2] Starting Backend...
+start "ImageForge Backend" /MIN cmd /k "set HF_HOME=d:/VSC Codes/Bild/.cache/hf && set TRANSFORMERS_CACHE=d:/VSC Codes/Bild/.cache/hf && set IMAGEFORGE_HOST=127.0.0.1 && set IMAGEFORGE_PORT=8008 && D:\VSC Codes\Bild\.venv\Scripts\python.exe -m backend.app.main"
+
+timeout /t 3 /nobreak >nul
+
+echo [2/2] Starting Frontend...
+cd frontend
+start "ImageForge Frontend" /MIN cmd /k "npm run dev"
+
+timeout /t 5 /nobreak >nul
+
+echo.
+echo ======================================
+echo   Services Started!
+echo ======================================
+echo   Backend:  http://127.0.0.1:8008
+echo   Frontend: http://127.0.0.1:5173
+echo ======================================
+echo.
+echo Opening UI in browser...
+timeout /t 2 /nobreak >nul
+start http://127.0.0.1:5173
+
+echo.
+echo Stack is running! Press any key to stop all services...
+pause >nul
+
+echo.
+echo Stopping services...
+taskkill /FI "WINDOWTITLE eq ImageForge*" /F >nul 2>&1
+echo Done!

ZIMAGETURBO_QUICKSTART.md

@@ -0,0 +1,171 @@
+# 🚀 Z-Image Turbo - Schnellstart für PixelForge
+
+## ⏱️ 5 Minuten Installation & Test
+
+### 1️⃣ Google Colab Vorbereitung (2 Min)
+
+```bash
+# 1. Gehe zu https://colab.research.google.com
+# 2. Wähle: File → Open notebook → Upload
+# 3. Wähle: pixelforge_colab_test.ipynb
+# 4. Runtime → Change runtime type → GPU (T4)
+# 5. Registriere bei https://ngrok.com (kostenlos)
+# 6. Kopiere Auth Token aus Account Settings
+```
+
+### 2️⃣ Colab Notebook Ausführen (2 Min)
+
+```python
+# Cell 1: Abhängigkeiten installieren
+# → Drücke Shift+Enter zum Ausführen
+
+# Cell 2: GPU-Check
+# → Sollte zeigen: "GPU T4 erkannt ✓"
+
+# Cell 3: Modell laden
+# → Lädt Stable Diffusion (ca. 2 GB)
+
+# Cell 4: Test-Generierung
+# → Generiert ein Testbild (~30 Sekunden)
+
+# Cell 5: API-Server starten
+# → Ersetze "YOUR_NGROK_TOKEN" mit deinem Token
+# → Drücke Ausführen & kopiere Public URL
+# → Z.B.: https://abc123def456.ngrok.io
+```
+
+### 3️⃣ PixelForge Starten (1 Min)
+
+**Option A: PowerShell (Empfohlen)**
+```powershell
+cd "d:\VSC Codes\Bild"
+.\start_zimageturbo.ps1
+# → Gebe Colab Ngrok-URL ein
+```
+
+**Option B: Batch-Datei**
+```cmd
+cd d:\VSC Codes\Bild
+start_zimageturbo.bat
+# → Gebe Colab Ngrok-URL ein
+```
+
+### 4️⃣ Terminal-Befehle (Manuell)
+
+```powershell
+# Backend
+cd "d:\VSC Codes\Bild\imageforge"
+$env:ZIMAGETURBO_API_URL = "https://abc123def456.ngrok.io"
+$env:ZIMAGETURBO_TIMEOUT = "300"
+& "D:/VSC Codes/Bild/.venv/Scripts/python.exe" -m backend.app.main
+
+# Separate PowerShell Tab:
+cd "d:\VSC Codes\Bild\imageforge\frontend"
+npm run dev:web
+```
+
+### 5️⃣ Im Browser Testen
+
+```
+1. Öffne: http://127.0.0.1:5173
+2. Wähle "Z-Image Turbo" im Modell-Dropdown
+3. Gib Prompt ein: "A beautiful sunset over mountains"
+4. Klicke "Generate"
+5. Warte 30-60 Sekunden
+6. Bild sollte in Browser erscheinen ✓
+```
+
+---
+
+## ✅ Checkliste
+
+- [ ] Colab-Konto aktiviert & GPU eingeschaltet
+- [ ] ngrok-Account registriert & Auth Token kopiert
+- [ ] pixelforge_colab_test.ipynb in Colab hochgeladen
+- [ ] Alle 5 Cells im Notebook ausgeführt
+- [ ] Ngrok Public URL kopiert (z.B. https://abc123.ngrok.io)
+- [ ] start_zimageturbo.ps1 oder .bat ausgeführt
+- [ ] ZIMAGETURBO_API_URL korrekt gesetzt
+- [ ] Backend läuft: http://127.0.0.1:8008/health (sollte OK sein)
+- [ ] Frontend läuft: http://127.0.0.1:5173 (sollte React-UI zeigen)
+- [ ] Test-Generierung abgeschlossen (echtes Bild!)
+
+---
+
+## 🆘 Häufige Probleme
+
+| Problem | Lösung |
+|---------|--------|
+| "API nicht erreichbar" | Colab noch am Laden? Oder Ngrok Token ungültig? |
+| "Timeout nach 300s" | Colab-Model zu lange zum Laden? Timeout erhöhen: `$env:ZIMAGETURBO_TIMEOUT = "600"` |
+| "Colab-Sitzung verloren" | Google Colab beendet nach 4h Leerlauf. Notebook neu starten! |
+| "Port 5173 bereits in Verwendung" | Alte Vite instanz lauft noch: `Get-Process -Name "node" \| Stop-Process` |
+| "Fehler: Unknown Provider" | Backend neu starten nach Env-Variablen-Änderung! |
+
+---
+
+## 📊 Performance erwartet
+
+| Hardware | Zeit | Qualität |
+|----------|------|----------|
+| Colab T4 GPU | 30-60s | High ⭐⭐⭐ |
+| Lokal tiny-sd | 5-10s | Medium ⭐⭐ |
+| i9 + RTX 4070 | 5-10s | High ⭐⭐⭐ |
+| RunPod A100 | 2-3s | Ultra ⭐⭐⭐⭐ |
+
+---
+
+## 🔧 Umgebungsvariablen
+
+```powershell
+# Manuell (falls nicht über Skript):
+$env:ZIMAGETURBO_API_URL = "https://deine-ngrok-url.ngrok.io"
+$env:ZIMAGETURBO_TIMEOUT = "300"          # Sekunden
+$env:ZIMAGETURBO_PROXY = ""               # Optional für Proxy
+
+# Oder permanent in Windows:
+# Systemsteuerung → Umgebungsvariablen → Neue Var hinzufügen
+```
+
+---
+
+## 🌐 Alternative: Lokale Installation (Ohne Colab)
+
+```bash
+# Wenn du Z-Image Turbo lokal installieren möchtest:
+# 1. Lade Modell von HuggingFace herunter
+# 2. Starte lokalen Flask-Server (ähnlich Colab-Notebook)
+# 3. Setze ZIMAGETURBO_API_URL auf http://localhost:5000
+```
+
+---
+
+## 📝 Mehrere Modelle testen
+
+Im ZIMAGETURBO_SETUP.md gibt es weitere Optionen:
+- **Stable Diffusion v1.5** (schnell, gut)
+- **Stable Diffusion XL** (langsam, sehr gut)
+- **Custom Models** von HuggingFace
+
+Ändere einfach im Colab Cell 3 das Modell!
+
+---
+
+## 💡 Tipps
+
+1. **Colab bleibt aktiv**: Öffne DevTools (F12) → Keep console open
+2. **Bessere Prompts**: Nutze Details wie "4K, professional, highly detailed"
+3. **Batch-Generierung**: Mehrere Prompts nacheinander → Job-Queue
+4. **Speichern**: Generierte Bilder landen in output/YYYY-MM-DD/job_*/
+
+---
+
+## ❓ Mehr Hilfe
+
+- **Technisches**: Siehe [ZIMAGETURBO_SETUP.md](ZIMAGETURBO_SETUP.md)
+- **Provider Code**: [zimageturbo_provider.py](imageforge/backend/app/providers/zimageturbo_provider.py)
+- **Colab-Notebook**: [pixelforge_colab_test.ipynb](pixelforge_colab_test.ipynb)
+
+---
+
+**Viel Spaß beim Testen! 🎨✨**

ZIMAGETURBO_SETUP.md

@@ -0,0 +1,96 @@
+# Z-Image Turbo Integration für PixelForge
+
+## Schritt 1: Google Colab Setup
+
+1. Öffne `pixelforge_colab_test.ipynb` in Google Colab
+2. Führe alle Cells aus:
+   - Dependencies installieren
+   - GPU-Check
+   - Modell laden (Colab T4 = ~2-3 Min)
+   - API-Server starten
+
+3. **Ngrok einrichten (für Public URL):**
+   ```bash
+   # Registriere dich auf ngrok.com (kostenlos)
+   # Kopiere Auth-Token in Colab Cell 5
+   ```
+
+## Schritt 2: PixelForge konfigurieren
+
+Setze diese **Umgebungsvariablen** vor dem Backend-Start:
+
+```powershell
+$env:ZIMAGETURBO_API_URL = "https://dein-ngrok-url.ngrok.io"  # Colab Public URL
+$env:ZIMAGETURBO_API_KEY = ""  # Leer, wenn keine Auth benötigt
+$env:ZIMAGETURBO_TIMEOUT = "300"  # 5 Minuten
+```
+
+**Beispiel (Windows PowerShell):**
+```powershell
+cd "d:/VSC Codes/Bild/imageforge"
+$env:ZIMAGETURBO_API_URL = "https://abc123.ngrok.io"
+& "D:/VSC Codes/Bild/.venv/Scripts/python.exe" -m backend.app.main
+```
+
+## Schritt 3: Backend-Start
+
+Backend wird neu gestartet und Z-Image Turbo sollte verfügbar sein:
+
+```
+[2026-02-20 12:34:56] ✓ Z-Image Turbo API verfügbar: https://abc123.ngrok.io
+```
+
+## Schritt 4: Im UI verwenden
+
+1. Öffne http://127.0.0.1:5173/
+2. Wechsle das Modell zu **"Z-Image Turbo"**
+3. Gib einen Prompt ein und klicke **"Generate"**
+4. Das Bild wird über Colab generiert ☁️
+
+## Lokale Installation (statt Colab)
+
+Wenn du Z-Image Turbo lokal installieren möchtest:
+
+```python
+# 1. Download & Install
+pip install z-image-turbo torch diffusers
+
+# 2. Lokaler API-Server (optional)
+from flask import Flask
+from z_image_turbo import Pipeline
+
+app = Flask(__name__)
+pipe = Pipeline("zimageturbo-fast")  # Oder dein Modell
+
+@app.route('/health', methods=['GET'])
+def health():
+    return {"status": "ok"}
+
+@app.route('/generate', methods=['POST'])
+def generate():
+    # ... generiere Bild ...
+    pass
+```
+
+Dann: `ZIMAGETURBO_API_URL=http://localhost:5000`
+
+## Tipps & Troubleshooting
+
+| Problem | Lösung |
+|---------|--------|
+| **API antwortet nicht** | Ngrok-URL in Colab und Env-Var prüfen |
+| **Timeout (300s zu kurz)** | `ZIMAGETURBO_TIMEOUT=600` erhöhen |
+| **Colab-Session beendet** | Notebook neu starten (Ngrok-Token erforderlich) |
+| **"Unknown provider"** | Backend Cache leeren: `killall python` + Neustart |
+
+## Performance
+
+| Setup | Speed | Kosten |
+|-------|-------|--------|
+| **Colab + T4** | 30-60s/Bild | Kostenlos |
+| **Lokal (RTX 4070)** | 5-10s/Bild | ~€500 |
+| **RunPod (A100)** | 2-3s/Bild | €0.50-1.00/h |
+
+---
+
+**Viel Spaß mit Z-Image Turbo! 🚀**

add_exit.txt

@@ -0,0 +1 @@
+EXIT:128

download_model.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+Download and cache a real Stable Diffusion model for offline use.
+This runs once, then the model is cached forever.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Setup cache
+cache_root = Path("d:/VSC Codes/Bild/.cache/hf")
+cache_root.mkdir(parents=True, exist_ok=True)
+
+os.environ['HF_HOME'] = str(cache_root)
+os.environ['TORCH_HOME'] = str(cache_root / 'torch')
+
+print(f"Cache directory: {cache_root}")
+print()
+
+# Use direct API instead of CLI
+print("Downloading Stable Diffusion 2.1...")
+print("(This is one-time setup, then cached offline)")
+print()
+
+try:
+    # Use snapshot_download which is more robust
+    from huggingface_hub import snapshot_download
+    
+    model_id = "stabilityai/stable-diffusion-2-1"
+    print(f"Model: {model_id}")
+    print()
+    print("Downloading (this may take 5-10 minutes on first run)...")
+    
+    model_path = snapshot_download(
+        repo_id=model_id,
+        cache_dir=str(cache_root),
+        local_dir_use_symlinks=False
+    )
+    
+    print()
+    print(f"✓ SUCCESS! Model cached at:")
+    print(f"  {model_path}")
+    print()
+    print("Backend can now generate images offline!")
+    sys.exit(0)
+    
+except Exception as e:
+    print(f"✗ FAILED: {type(e).__name__}: {e}")
+    print()
+    print("Trying tiny-sd as fallback (smaller, faster)...")
+    print()
+    
+    try:
+        from huggingface_hub import snapshot_download
+        model_id = "segmind/tiny-sd"
+        model_path = snapshot_download(
+            repo_id=model_id,
+            cache_dir=str(cache_root),
+            local_dir_use_symlinks=False
+        )
+        print(f"✓ Fallback successful! Cached at: {model_path}")
+        sys.exit(0)
+    except Exception as e2:
+        print(f"✗ Fallback failed: {e2}")
+        sys.exit(1)

download_sd15.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+import os
+import sys
+from pathlib import Path
+from huggingface_hub import snapshot_download
+
+os.environ['HF_HUB_DISABLE_SYMLINKS'] = '1'
+
+cache = Path("d:/VSC Codes/Bild/.cache/hf")
+cache.mkdir(parents=True, exist_ok=True)
+
+print("Downloading runwayml/stable-diffusion-v1-5...")
+print("(~4GB, this is one-time setup)")
+print()
+
+try:
+    path = snapshot_download(
+        "runwayml/stable-diffusion-v1-5",
+        cache_dir=str(cache),
+        local_dir_use_symlinks=False
+    )
+    print()
+    print(f"✓ SUCCESS!")
+    print(f"Model cached to: {path}")
+    print()
+    print("ImageForge can now generate real images!")
+    sys.exit(0)
+except Exception as e:
+    print(f"✗ Error: {e}")
+    sys.exit(1)

download_tiny_sd.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Download tiny-sd model - FAST download, REAL images (not dummy)"""
+import os
+import sys
+from pathlib import Path
+from huggingface_hub import snapshot_download
+
+os.environ['HF_HUB_DISABLE_SYMLINKS'] = '1'
+cache = Path("d:/VSC Codes/Bild/.cache/hf")
+
+print("=" * 60)
+print("  QUICK MODEL DOWNLOAD: tiny-sd")
+print("=" * 60)
+print()
+print("This is a small model (~600MB) that generates REAL images")
+print("(Not as good as SD 1.5, but better than white dummy images)")
+print()
+
+try:
+    print("Downloading segmind/tiny-sd...")
+    path = snapshot_download(
+        "segmind/tiny-sd",
+        cache_dir=str(cache),
+        local_dir_use_symlinks=False
+    )
+    print()
+    print("=" * 60)
+    print("✓ SUCCESS!")
+    print("=" * 60)
+    print(f"Model cached at: {path}")
+    print()
+    print("Backend can now generate REAL images!")
+    print("Just restart the backend to use it.")
+    sys.exit(0)
+except Exception as e:
+    print(f"✗ Error: {e}")
+    sys.exit(1)

imageforge/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install Python deps
+        run: pip install -r requirements.txt
+      - name: Run backend tests
+        run: pytest
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+      - name: Install frontend deps
+        run: npm --prefix frontend ci
+      - name: Typecheck frontend
+        run: npm --prefix frontend run typecheck
+      - name: Build renderer
+        run: npm --prefix frontend run build:renderer
+      - name: Install Playwright browser
+        run: npx --prefix frontend playwright install --with-deps chromium
+      - name: Run E2E smoke
+        run: npm --prefix frontend run test:e2e

imageforge/.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+*.pyc
+.venv/
+venv/
+node_modules/
+frontend/node_modules/
+frontend/dist/
+frontend/dist-electron/
+output/
+app.log
+prompt_history.json
+.pytest_cache/
+frontend/test-results/
+frontend/playwright-report/
+backups/
+jobs_state.json
+settings.json
+admin_audit.log

imageforge/.npmrc

@@ -0,0 +1,2 @@
+cache=D:/AI/npm-cache
+logs-dir=D:/AI/npm-cache/_logs

imageforge/README.md

@@ -0,0 +1,199 @@
+# ImageForge
+
+ImageForge ist eine lokal laufende Desktop-App zur Bild-Erstellung per Prompt. Die App nutzt ein Python-Backend (FastAPI + Job-Queue) und ein Electron+React-Frontend.
+
+## Features
+
+- Prompt + Negative Prompt
+- Modellauswahl (`dummy`, `localai`, `diffusion`)
+- Bildtyp-Presets und Stil-Presets
+- Image-to-Image (Startbild + Strength)
+- Dashboard (Queue, Status, Retry/Cancel, Compare)
+- Preset-System (CRUD)
+- Export (PNG/JPG/WEBP)
+- Prompt-Versionierung (`config_hash` in `meta.json`)
+- API-Key + Rollenmodell (`viewer`, `operator`, `admin`)
+- Rate-Limit pro Client
+- Health + Readiness + Metrics
+- Recovery von Job-Status nach Neustart
+- Storage-Governance (Retention-Cleanup)
+
+## Setup
+
+```powershell
+cd imageforge
+python -m venv .venv
+.\.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+npm --prefix frontend install
+```
+
+## Start
+
+```powershell
+npm run dev
+```
+
+Für den kompletten lokalen Stack (Backend + Frontend, inkl. Healthcheck):
+
+```powershell
+npm run dev:stack
+```
+
+## Serverbetrieb
+
+```powershell
+$env:IMAGEFORGE_HOST="0.0.0.0"
+$env:IMAGEFORGE_PORT="8008"
+$env:IMAGEFORGE_CORS_ORIGINS="http://localhost:5173"
+$env:IMAGEFORGE_API_KEYS="viewerKey:viewer,opsKey:operator,adminKey:admin"
+$env:IMAGEFORGE_RATE_LIMIT_PER_MIN="120"
+$env:IMAGEFORGE_CONTENT_PROFILE="internal-relaxed"
+$env:IMAGEFORGE_ADMIN_TOKEN="change-me"
+python -m backend.app.main
+```
+
+## Wichtige Endpunkte
+
+- `GET /health`
+- `GET /ready`
+- `GET /metrics`
+- `GET /metrics/prometheus`
+- `POST /generate`
+- `GET /jobs`
+- `POST /jobs/{id}/retry`
+- `POST /jobs/{id}/cancel`
+- `GET /dashboard/stats`
+- `GET/POST/DELETE /presets`
+- `POST /export`
+- `GET/PUT /admin/settings`
+- `POST /admin/cleanup`
+
+## Security und Policy
+
+- API-Key Header: `X-ImageForge-Api-Key`
+- Admin Override Header: `X-ImageForge-Admin-Token`
+- Policy Profile:
+  - `strict`
+  - `internal-relaxed`
+- Audit-Logs:
+  - `policy_audit.log`
+  - `admin_audit.log`
+
+## Backup / Restore
+
+```powershell
+npm run backup
+npm run restore -- -Source backups\imageforge_backup_YYYYMMDD_HHMMSS
+```
+
+## Tests
+
+```powershell
+npm run test
+npm run test:e2e
+```
+
+## CI
+
+GitHub Actions Workflow liegt in `.github/workflows/ci.yml`.
+
+## Optional LocalAI / Diffusion
+
+```powershell
+pip install diffusers torch transformers accelerate
+$env:IMAGEFORGE_LOCALAI_MODEL="stabilityai/sd-turbo"
+$env:IMAGEFORGE_LOCALAI_IMAGE_TIMEOUT_SECONDS="180"
+$env:IMAGEFORGE_LOCALAI_LOCAL_ONLY="1"
+$env:IMAGEFORGE_ENABLE_ATTENTION_SLICING="1"
+```
+
+Wenn `torch.cuda.is_available()` auf `False` bleibt, ist oft eine CPU-only Torch-Build installiert.
+Für NVIDIA-GPU unter Windows kann eine CUDA-Build so installiert werden:
+
+```powershell
+python -m pip install --upgrade --index-url https://download.pytorch.org/whl/cu121 torch torchvision torchaudio
+```
+
+## Optional AUTOMATIC1111 Integration
+
+ImageForge kann AUTOMATIC1111 als Provider nutzen (`model = a1111`).
+
+### Empfohlener Produktionspfad (Stability Matrix)
+
+Für stabilen Betrieb auf Windows wird eine **saubere, manager-gesteuerte Installation** empfohlen (statt manuell gepatchter `stable-diffusion-webui`-Klone):
+
+1. Stability Matrix installieren und dort eine frische WebUI-Instanz mit aktivierter API starten.
+2. API-Endpunkt prüfen:
+
+```powershell
+Invoke-RestMethod http://127.0.0.1:7860/sdapi/v1/sd-models
+```
+
+3. ImageForge auf diese Instanz zeigen (Default ist bereits `127.0.0.1:7860`):
+
+```powershell
+$env:IMAGEFORGE_A1111_BASE_URL="http://127.0.0.1:7860"
+```
+
+1. AUTOMATIC1111 lokal starten (mit API), z. B.:
+
+```powershell
+webui-user.bat --api
+```
+
+2. Optional URL/Timeout konfigurieren:
+
+```powershell
+$env:IMAGEFORGE_A1111_BASE_URL="http://127.0.0.1:7860"
+$env:IMAGEFORGE_A1111_TIMEOUT_SECONDS="180"
+$env:IMAGEFORGE_A1111_HEALTH_ENDPOINT="/sdapi/v1/sd-models"
+$env:IMAGEFORGE_A1111_RETRY_COUNT="2"
+$env:IMAGEFORGE_A1111_RETRY_BACKOFF_SECONDS="1.0"
+```
+
+Falls A1111 mit `--api-auth user:password` läuft:
+
+```powershell
+$env:IMAGEFORGE_A1111_API_USER="user"
+$env:IMAGEFORGE_A1111_API_PASSWORD="password"
+```
+
+Alternativ als ein String:
+
+```powershell
+$env:IMAGEFORGE_A1111_API_AUTH="user:password"
+```
+
+Danach erscheint `AUTOMATIC1111` in `/models` als verfügbar, sobald der A1111-Server erreichbar ist.
+
+### Robuster Betrieb bei A1111-Ausfällen
+
+Wenn A1111 nicht erreichbar ist oder Fehler liefert, kann ImageForge automatisch auf andere Provider wechseln (z. B. `localai`, `diffusion`, `dummy`) statt den Job direkt abzubrechen.
+
+```powershell
+$env:IMAGEFORGE_ENABLE_AUTO_FALLBACK="1"
+$env:IMAGEFORGE_FALLBACK_MODELS="a1111,localai,diffusion,dummy"
+$env:IMAGEFORGE_FALLBACK_TIMEOUT_SECONDS="90"
+$env:IMAGEFORGE_FALLBACK_MAX_STEPS="24"
+```
+
+- `IMAGEFORGE_ENABLE_AUTO_FALLBACK`: `1` aktiviert automatische Umschaltung.
+- `IMAGEFORGE_FALLBACK_MODELS`: Priorisierte Reihenfolge der Fallback-Provider.
+- `IMAGEFORGE_FALLBACK_TIMEOUT_SECONDS`: Kürzerer Timeout pro Fallback-Versuch.
+- `IMAGEFORGE_FALLBACK_MAX_STEPS`: Deckel für Steps bei Fallback, um Laufzeit zu reduzieren.
+
+### Stack-Readiness prüfen
+
+Nach dem Start von Backend und A1111:
+
+```powershell
+./scripts/healthcheck-stack.ps1 -RequireA1111
+```
+
+Das Skript validiert `/health`, `/ready`, `/models` und optional die A1111-API selbst.
+
+## Troubleshooting
+
+- Falls Desktop-Build auf Windows an Symlink-Rechten scheitert: Entwickler-Modus oder Admin-Rechte aktivieren.
+- Logs: `app.log`, `policy_audit.log`, `admin_audit.log`.

imageforge/backend/__init__.py

@@ -0,0 +1 @@
+

imageforge/backend/app/__init__.py

@@ -0,0 +1 @@
+

imageforge/backend/app/api/__init__.py

@@ -0,0 +1 @@
+

imageforge/backend/app/api/schemas.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class JobStatus(str, Enum):
+    QUEUED = "queued"
+    RUNNING = "running"
+    DONE = "done"
+    ERROR = "error"
+    CANCELLED = "cancelled"
+
+
+class GenerateRequest(BaseModel):
+    prompt: str = Field(min_length=1, max_length=2000)
+    negative_prompt: str = Field(default="", max_length=2000)
+    model: str = Field(default="localai")  # Changed from "dummy" to "localai"
+    size: Literal["512x512", "768x768", "1024x1024", "1024x1536", "1536x1024"] = "512x512"
+    count: int = Field(default=1, ge=1, le=4)
+    seed: int | None = Field(default=None, ge=0)
+    random_seed: bool = True
+    steps: int = Field(default=30, ge=1, le=100)
+    guidance: float = Field(default=6.5, ge=1.0, le=20.0)
+    image_type: Literal[
+        "general",
+        "photo",
+        "portrait",
+        "landscape",
+        "architecture",
+        "product",
+        "logo",
+        "icon",
+        "poster",
+        "illustration",
+        "anime",
+        "pixel_art",
+        "sketch",
+        "painting",
+        "3d",
+    ] = "general"
+    style_preset: Literal[
+        "auto",
+        "photorealistic",
+        "cinematic",
+        "minimal",
+        "vibrant",
+        "monochrome",
+        "watercolor",
+        "oil",
+        "noir",
+        "fantasy",
+    ] = "auto"
+    style_strength: int = Field(default=60, ge=0, le=100)
+    admin_override: bool = False
+    init_image_path: str | None = None
+    img2img_strength: float = Field(default=0.45, ge=0.0, le=1.0)
+    model_variant: str | None = Field(default=None, max_length=200)
+
+    @field_validator("prompt")
+    @classmethod
+    def validate_prompt(cls, value: str) -> str:
+        value = value.strip()
+        if not value:
+            raise ValueError("Prompt must not be empty")
+        return value
+
+
+class GenerateResponse(BaseModel):
+    job_id: str
+
+
+class RetryResponse(BaseModel):
+    old_job_id: str
+    new_job_id: str
+
+
+class JobInfoResponse(BaseModel):
+    job_id: str
+    status: JobStatus
+    progress: int
+    message: str
+    created_at: datetime
+    updated_at: datetime
+    image_paths: list[str] = Field(default_factory=list)
+    output_dir: str | None = None
+    error: str | None = None
+
+
+class CancelResponse(BaseModel):
+    success: bool
+
+
+class ModelInfo(BaseModel):
+    id: str
+    name: str
+    available: bool
+    description: str
+
+
+class HistoryItem(BaseModel):
+    prompt: str
+    negative_prompt: str
+    timestamp: datetime
+
+
+class HealthResponse(BaseModel):
+    status: str
+    timestamp: datetime
+
+
+class PresetPayload(BaseModel):
+    name: str = Field(min_length=1, max_length=80)
+    prompt: str = ""
+    negative_prompt: str = ""
+    model: str = "dummy"
+    size: Literal["512x512", "768x768", "1024x1024", "1024x1536", "1536x1024"] = "512x512"
+    count: int = Field(default=1, ge=1, le=4)
+    steps: int = Field(default=30, ge=1, le=100)
+    guidance: float = Field(default=6.5, ge=1.0, le=20.0)
+    image_type: str = "general"
+    style_preset: str = "auto"
+    style_strength: int = Field(default=60, ge=0, le=100)
+
+
+class PresetResponse(PresetPayload):
+    updated_at: datetime
+
+
+class DashboardStats(BaseModel):
+    queued: int
+    running: int
+    done: int
+    error: int
+    cancelled: int
+    total: int
+    last_24h: int
+
+
+class ExportRequest(BaseModel):
+    source_path: str
+    format: Literal["png", "jpg", "webp"] = "png"
+    quality: int = Field(default=92, ge=1, le=100)
+    max_width: int | None = Field(default=None, ge=64, le=8192)
+    max_height: int | None = Field(default=None, ge=64, le=8192)
+
+
+class ExportResponse(BaseModel):
+    output_path: str
+
+
+class AdminSettings(BaseModel):
+    content_profile: str
+    rate_limit_per_minute: int
+    output_retention_days: int
+    adult_enabled: bool = False
+
+
+class MetricsResponse(BaseModel):
+    metrics: dict[str, float | int]

imageforge/backend/app/core/__init__.py

@@ -0,0 +1 @@
+

imageforge/backend/app/core/config.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parents[3]
+AI_CACHE_ROOT = Path(os.getenv("IMAGEFORGE_CACHE_ROOT", str(BASE_DIR / ".cache"))).resolve()
+AI_TMP_ROOT = Path(os.getenv("IMAGEFORGE_TMP_ROOT", str(AI_CACHE_ROOT / "tmp"))).resolve()
+
+for directory in [
+	AI_CACHE_ROOT,
+	AI_CACHE_ROOT / "hf",
+	AI_CACHE_ROOT / "hf" / "transformers",
+	AI_CACHE_ROOT / "torch",
+	AI_CACHE_ROOT / "pip",
+	AI_TMP_ROOT,
+]:
+	directory.mkdir(parents=True, exist_ok=True)
+
+os.environ.setdefault("HF_HOME", str(AI_CACHE_ROOT / "hf"))
+os.environ.setdefault("TRANSFORMERS_CACHE", str(AI_CACHE_ROOT / "hf" / "transformers"))
+os.environ.setdefault("TORCH_HOME", str(AI_CACHE_ROOT / "torch"))
+os.environ.setdefault("PIP_CACHE_DIR", str(AI_CACHE_ROOT / "pip"))
+os.environ.setdefault("TMP", str(AI_TMP_ROOT))
+os.environ.setdefault("TEMP", str(AI_TMP_ROOT))
+
+OUTPUT_DIR = BASE_DIR / "output"
+LOG_FILE = BASE_DIR / "app.log"
+POLICY_AUDIT_FILE = BASE_DIR / "policy_audit.log"
+HISTORY_FILE = BASE_DIR / "prompt_history.json"
+PRESETS_FILE = BASE_DIR / "presets.json"
+JOBS_STATE_FILE = BASE_DIR / "jobs_state.json"
+SETTINGS_FILE = BASE_DIR / "settings.json"
+ADMIN_AUDIT_FILE = BASE_DIR / "admin_audit.log"
+DEFAULT_BACKEND_HOST = os.getenv("IMAGEFORGE_HOST", "127.0.0.1")
+DEFAULT_BACKEND_PORT = int(os.getenv("IMAGEFORGE_PORT", "8008"))
+CORS_ORIGINS = os.getenv("IMAGEFORGE_CORS_ORIGINS", "*")
+CONTENT_PROFILE = os.getenv("IMAGEFORGE_CONTENT_PROFILE", "strict")
+ADMIN_TOKEN = os.getenv("IMAGEFORGE_ADMIN_TOKEN", "")
+API_KEYS = os.getenv("IMAGEFORGE_API_KEYS", "")
+RATE_LIMIT_PER_MINUTE = int(os.getenv("IMAGEFORGE_RATE_LIMIT_PER_MIN", "120"))
+REQUEST_MAX_BYTES = int(os.getenv("IMAGEFORGE_REQUEST_MAX_BYTES", str(2 * 1024 * 1024)))
+OUTPUT_RETENTION_DAYS = int(os.getenv("IMAGEFORGE_OUTPUT_RETENTION_DAYS", "30"))
+DASHBOARD_REFRESH_SECONDS = int(os.getenv("IMAGEFORGE_DASHBOARD_REFRESH_SECONDS", "2"))
+JOB_TIMEOUT_SECONDS = int(os.getenv("IMAGEFORGE_JOB_TIMEOUT_SECONDS", "180"))
+A1111_BASE_URL = os.getenv("IMAGEFORGE_A1111_BASE_URL", "http://127.0.0.1:7860")
+A1111_TIMEOUT_SECONDS = int(os.getenv("IMAGEFORGE_A1111_TIMEOUT_SECONDS", "180"))
+A1111_HEALTH_ENDPOINT = os.getenv("IMAGEFORGE_A1111_HEALTH_ENDPOINT", "/sdapi/v1/sd-models")
+A1111_RETRY_COUNT = int(os.getenv("IMAGEFORGE_A1111_RETRY_COUNT", "2"))
+A1111_RETRY_BACKOFF_SECONDS = float(os.getenv("IMAGEFORGE_A1111_RETRY_BACKOFF_SECONDS", "1.0"))
+A1111_API_AUTH = os.getenv("IMAGEFORGE_A1111_API_AUTH", "")
+A1111_API_USER = os.getenv("IMAGEFORGE_A1111_API_USER", "")
+A1111_API_PASSWORD = os.getenv("IMAGEFORGE_A1111_API_PASSWORD", "")

imageforge/backend/app/core/logging.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import logging
+from logging.handlers import RotatingFileHandler
+
+from .config import LOG_FILE
+
+
+def setup_logging() -> None:
+    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    root = logging.getLogger()
+    if root.handlers:
+        return
+
+    root.setLevel(logging.INFO)
+    formatter = logging.Formatter(
+        "%(asctime)s | %(levelname)s | %(name)s | %(message)s"
+    )
+
+    file_handler = RotatingFileHandler(LOG_FILE, maxBytes=1_000_000, backupCount=3)
+    file_handler.setFormatter(formatter)
+    root.addHandler(file_handler)
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(formatter)
+    root.addHandler(stream_handler)

imageforge/backend/app/core/observability.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import threading
+from collections import defaultdict
+
+
+class MetricsStore:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._counters: dict[str, int] = defaultdict(int)
+        self._timings_ms_sum: dict[str, float] = defaultdict(float)
+        self._timings_count: dict[str, int] = defaultdict(int)
+
+    def incr(self, key: str, delta: int = 1) -> None:
+        with self._lock:
+            self._counters[key] += delta
+
+    def observe_ms(self, key: str, value_ms: float) -> None:
+        with self._lock:
+            self._timings_ms_sum[key] += value_ms
+            self._timings_count[key] += 1
+
+    def snapshot(self) -> dict[str, float | int]:
+        with self._lock:
+            out: dict[str, float | int] = dict(self._counters)
+            for key, total in self._timings_ms_sum.items():
+                count = max(1, self._timings_count[key])
+                out[f"{key}_avg_ms"] = total / count
+                out[f"{key}_count"] = self._timings_count[key]
+            return out
+
+    def to_prometheus(self) -> str:
+        data = self.snapshot()
+        lines = ["# TYPE imageforge_metric gauge"]
+        for key, value in sorted(data.items()):
+            prom_name = "imageforge_" + key.replace("-", "_").replace("/", "_").replace(".", "_")
+            lines.append(f"{prom_name} {value}")
+        return "\n".join(lines) + "\n"

imageforge/backend/app/core/policy.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from datetime import datetime, timezone
+
+from .config import POLICY_AUDIT_FILE
+
+
+HARD_BLOCK_PATTERNS = [
+    r"\bminor\b",
+    r"\bunderage\b",
+    r"\bchild\b",
+    r"\bteen\s*sex\b",
+    r"\brape\b",
+    r"\bsexual\s*assault\b",
+    r"\bnon\s*-?consensual\b",
+    r"\bforced\s*sex\b",
+    r"\bincest\b",
+    r"\bbestiality\b",
+]
+
+ADULT_SEXUAL_PATTERNS = [
+    r"\berotic\b",
+    r"\bsensual\b",
+    r"\bnude\b",
+    r"\bnudity\b",
+    r"\bsexy\b",
+    r"\blingerie\b",
+    r"\badult\b",
+]
+
+EXPLICIT_PATTERNS = [
+    r"\bporn\b",
+    r"\bhardcore\b",
+    r"\bexplicit\s*sex\b",
+    r"\bpenetration\b",
+    r"\bblowjob\b",
+    r"\bsex\s*act\b",
+]
+
+
+@dataclass(slots=True)
+class PolicyDecision:
+    allowed: bool
+    reason: str
+    matched: list[str]
+
+
+class ContentPolicy:
+    def __init__(self, profile: str) -> None:
+        self.profile = profile.strip().lower() or "strict"
+
+    def evaluate(self, text: str, admin_override: bool) -> PolicyDecision:
+        combined = text.lower()
+        hard_hits = _find_matches(combined, HARD_BLOCK_PATTERNS)
+        if hard_hits:
+            return PolicyDecision(False, "blocked_illegal_content", hard_hits)
+
+        sexual_hits = _find_matches(combined, ADULT_SEXUAL_PATTERNS)
+        explicit_hits = _find_matches(combined, EXPLICIT_PATTERNS)
+
+        if self.profile == "strict":
+            if (sexual_hits or explicit_hits) and not admin_override:
+                return PolicyDecision(False, "blocked_sexual_in_strict_profile", sexual_hits + explicit_hits)
+            if (sexual_hits or explicit_hits) and admin_override:
+                return PolicyDecision(True, "allowed_admin_override", sexual_hits + explicit_hits)
+
+        if self.profile == "internal-relaxed":
+            if explicit_hits and not admin_override:
+                return PolicyDecision(False, "explicit_requires_admin_override", explicit_hits)
+            if explicit_hits and admin_override:
+                return PolicyDecision(True, "allowed_explicit_admin_override", explicit_hits)
+            if sexual_hits:
+                return PolicyDecision(True, "allowed_adult_sexual_relaxed", sexual_hits)
+
+        return PolicyDecision(True, "allowed", [])
+
+
+class PolicyAuditStore:
+    def write(
+        self,
+        *,
+        prompt: str,
+        negative_prompt: str,
+        profile: str,
+        decision: PolicyDecision,
+        client_ip: str,
+        model: str,
+        admin_override_requested: bool,
+        admin_override_applied: bool,
+    ) -> None:
+        POLICY_AUDIT_FILE.parent.mkdir(parents=True, exist_ok=True)
+        entry = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "profile": profile,
+            "allowed": decision.allowed,
+            "reason": decision.reason,
+            "matched": decision.matched,
+            "model": model,
+            "client_ip": client_ip,
+            "admin_override_requested": admin_override_requested,
+            "admin_override_applied": admin_override_applied,
+            "prompt_preview": prompt[:180],
+            "negative_prompt_preview": negative_prompt[:180],
+        }
+        with POLICY_AUDIT_FILE.open("a", encoding="utf-8") as fp:
+            fp.write(json.dumps(entry, ensure_ascii=True) + "\n")
+
+
+def _find_matches(text: str, patterns: list[str]) -> list[str]:
+    matches: list[str] = []
+    for pattern in patterns:
+        if re.search(pattern, text, flags=re.IGNORECASE):
+            matches.append(pattern)
+    return matches

imageforge/backend/app/core/prompting.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+_IMAGE_TYPE_HINTS: dict[str, str] = {
+    "general": "high quality image",
+    "photo": "real-world photography, natural lighting, realistic textures",
+    "portrait": "portrait photography, detailed face, sharp eyes, skin texture",
+    "landscape": "wide landscape composition, depth, atmospheric perspective",
+    "architecture": "architectural photography, perspective lines, material details",
+    "product": "studio product shot, clean background, commercial lighting",
+    "logo": "minimal vector logo, clean geometry, high contrast",
+    "icon": "flat app icon design, simple silhouette, readable at small size",
+    "poster": "poster design, bold composition, impactful typography space",
+    "illustration": "digital illustration, clean linework, cohesive color palette",
+    "anime": "anime style illustration, expressive line art, cel shading",
+    "pixel_art": "pixel art style, crisp pixels, limited palette",
+    "sketch": "pencil sketch, rough strokes, paper texture",
+    "painting": "painterly artwork, brush strokes, rich color blending",
+    "3d": "3d render style, global illumination, physically based materials",
+}
+
+_STYLE_HINTS: dict[str, str] = {
+    "auto": "",
+    "photorealistic": "photorealistic, ultra detailed, natural color grading",
+    "cinematic": "cinematic lighting, dramatic framing, filmic color",
+    "minimal": "minimalist design, clean shapes, negative space",
+    "vibrant": "vivid colors, high saturation, energetic contrast",
+    "monochrome": "monochrome palette, tonal depth, strong value structure",
+    "watercolor": "watercolor texture, soft pigment edges",
+    "oil": "oil painting texture, impasto details",
+    "noir": "film noir, moody shadows, high contrast",
+    "fantasy": "fantasy art, epic atmosphere, imaginative details",
+}
+
+_BASE_NEGATIVE = (
+    "low quality, blurry, noisy, jpeg artifacts, deformed anatomy, bad composition, "
+    "watermark, signature, text clutter"
+)
+
+
+@dataclass(slots=True)
+class PromptCompileResult:
+    prompt: str
+    negative_prompt: str
+
+
+def compile_prompts(
+    prompt: str,
+    negative_prompt: str,
+    image_type: str,
+    style_preset: str,
+    style_strength: int,
+) -> PromptCompileResult:
+    type_hint = _IMAGE_TYPE_HINTS.get(image_type, _IMAGE_TYPE_HINTS["general"])
+    style_hint = _STYLE_HINTS.get(style_preset, "")
+
+    strength = max(0, min(100, style_strength))
+    style_weight = ""
+    if style_hint:
+        style_weight = f" style influence {strength}%: {style_hint}."
+
+    compiled_prompt = f"{prompt.strip()}. Target: {type_hint}.{style_weight}".strip()
+
+    merged_negative = _BASE_NEGATIVE
+    if negative_prompt.strip():
+        merged_negative = f"{negative_prompt.strip()}, {merged_negative}"
+
+    return PromptCompileResult(prompt=compiled_prompt, negative_prompt=merged_negative)

imageforge/backend/app/core/security.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import time
+from collections import defaultdict, deque
+from dataclasses import dataclass
+
+from fastapi import HTTPException
+
+from .config import API_KEYS, RATE_LIMIT_PER_MINUTE
+
+
+@dataclass(slots=True)
+class Principal:
+    client_id: str
+    role: str
+    api_key: str | None
+
+
+class ApiSecurity:
+    def __init__(self) -> None:
+        self.required_keys: dict[str, str] = {}
+        for raw in [item.strip() for item in API_KEYS.split(",") if item.strip()]:
+            if ":" in raw:
+                key, role = raw.split(":", maxsplit=1)
+                self.required_keys[key.strip()] = role.strip() or "operator"
+            else:
+                self.required_keys[raw] = "operator"
+        self.limit = RATE_LIMIT_PER_MINUTE
+        self._hits: dict[str, deque[float]] = defaultdict(deque)
+
+    def authenticate(self, api_key: str | None, client_id: str) -> Principal:
+        role = "operator"
+        if self.required_keys:
+            if not api_key or api_key not in self.required_keys:
+                raise HTTPException(status_code=401, detail="Missing or invalid API key")
+            role = self.required_keys[api_key]
+        self._check_rate_limit(client_id)
+        return Principal(client_id=client_id, role=role, api_key=api_key)
+
+    @staticmethod
+    def require_role(principal: Principal, minimum_role: str) -> None:
+        rank = {"viewer": 1, "operator": 2, "admin": 3}
+        if rank.get(principal.role, 0) < rank.get(minimum_role, 0):
+            raise HTTPException(status_code=403, detail=f"Role '{minimum_role}' required")
+
+    def _check_rate_limit(self, client_id: str) -> None:
+        if client_id in {"127.0.0.1", "::1", "localhost"}:
+            return
+        now = time.time()
+        q = self._hits[client_id]
+        window_start = now - 60.0
+        while q and q[0] < window_start:
+            q.popleft()
+        if len(q) >= self.limit:
+            raise HTTPException(status_code=429, detail="Rate limit exceeded")
+        q.append(now)

imageforge/backend/app/jobs/__init__.py

@@ -0,0 +1 @@
+

imageforge/backend/app/jobs/manager.py

@@ -0,0 +1,455 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import queue
+import threading
+import time
+import uuid
+import os
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+import random
+
+from ..api.schemas import GenerateRequest, JobStatus
+from ..core.config import JOBS_STATE_FILE, JOB_TIMEOUT_SECONDS, OUTPUT_DIR
+from ..core.prompting import compile_prompts
+from ..providers.factory import ProviderRegistry
+from ..providers.interface import ProviderRequest, ProviderResult, ProviderUnavailableError
+from ..storage.history import PromptHistoryStore
+
+LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class JobState:
+    job_id: str
+    request: GenerateRequest
+    status: JobStatus = JobStatus.QUEUED
+    progress: int = 0
+    message: str = "Queued"
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    image_paths: list[str] = field(default_factory=list)
+    output_dir: str | None = None
+    error: str | None = None
+    cancel_requested: bool = False
+
+
+class JobManager:
+    def __init__(
+        self,
+        provider_registry: ProviderRegistry,
+        history_store: PromptHistoryStore,
+        state_file: Path | None = None,
+    ) -> None:
+        self.provider_registry = provider_registry
+        self.history_store = history_store
+        self._state_file = state_file or JOBS_STATE_FILE
+        self._jobs: dict[str, JobState] = {}
+        self._queue: queue.Queue[str] = queue.Queue()
+        self._lock = threading.RLock()
+        self._state_write_lock = threading.Lock()
+        self._worker = threading.Thread(target=self._worker_loop, daemon=True)
+        self._load_state()
+        self._worker.start()
+
+    def submit(self, request: GenerateRequest) -> str:
+        job_id = uuid.uuid4().hex[:12]
+        state = JobState(job_id=job_id, request=request)
+        with self._lock:
+            self._jobs[job_id] = state
+        self._queue.put(job_id)
+        self.history_store.add(request.prompt, request.negative_prompt)
+        self._save_state()
+        LOGGER.info("Job %s queued with model %s", job_id, request.model)
+        return job_id
+
+    def get(self, job_id: str) -> JobState | None:
+        with self._lock:
+            return self._jobs.get(job_id)
+
+    def list(self) -> list[JobState]:
+        with self._lock:
+            return sorted(self._jobs.values(), key=lambda item: item.created_at, reverse=True)
+
+    def retry(self, job_id: str) -> str | None:
+        with self._lock:
+            state = self._jobs.get(job_id)
+        if state is None:
+            return None
+        return self.submit(state.request)
+
+    def stats(self) -> dict[str, int]:
+        with self._lock:
+            items = list(self._jobs.values())
+        now = datetime.now(timezone.utc)
+        counts = {status.value: 0 for status in JobStatus}
+        last_24h = 0
+        for item in items:
+            counts[item.status.value] += 1
+            if (now - item.created_at).total_seconds() <= 86400:
+                last_24h += 1
+        return {
+            "queued": counts["queued"],
+            "running": counts["running"],
+            "done": counts["done"],
+            "error": counts["error"],
+            "cancelled": counts["cancelled"],
+            "total": len(items),
+            "last_24h": last_24h,
+        }
+
+    def cancel(self, job_id: str) -> bool:
+        with self._lock:
+            state = self._jobs.get(job_id)
+            if state is None:
+                return False
+            state.cancel_requested = True
+            if state.status == JobStatus.QUEUED:
+                state.status = JobStatus.CANCELLED
+                state.message = "Cancelled"
+                state.updated_at = datetime.now(timezone.utc)
+                self._save_state()
+            return True
+
+    def _update(self, job_id: str, **updates) -> None:  # noqa: ANN003
+        with self._lock:
+            state = self._jobs.get(job_id)
+            if state is None:
+                return
+            for key, value in updates.items():
+                setattr(state, key, value)
+            state.updated_at = datetime.now(timezone.utc)
+            self._save_state()
+
+    def _worker_loop(self) -> None:
+        while True:
+            job_id = self._queue.get()
+            state = self.get(job_id)
+            if state is None:
+                continue
+            if state.status == JobStatus.CANCELLED:
+                continue
+            self._run_job(job_id, state)
+
+    def _run_job(self, job_id: str, state: JobState) -> None:
+        self._update(job_id, status=JobStatus.RUNNING, progress=1, message="Starting generation")
+        date_dir = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        output_dir = OUTPUT_DIR / date_dir / f"job_{job_id}"
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        try:
+            width, height = self._parse_size(state.request.size)
+            seed = state.request.seed
+            if state.request.random_seed or seed is None:
+                seed = random.randint(0, 2**31 - 1)
+            if state.request.init_image_path:
+                init_path = Path(state.request.init_image_path)
+                if not init_path.exists() or not init_path.is_file():
+                    raise ValueError("init_image_path does not exist or is not a file")
+            compiled = compile_prompts(
+                prompt=state.request.prompt,
+                negative_prompt=state.request.negative_prompt,
+                image_type=state.request.image_type,
+                style_preset=state.request.style_preset,
+                style_strength=state.request.style_strength,
+            )
+
+            provider_request = ProviderRequest(
+                prompt=compiled.prompt,
+                negative_prompt=compiled.negative_prompt,
+                count=state.request.count,
+                width=width,
+                height=height,
+                seed=seed,
+                steps=state.request.steps,
+                guidance=state.request.guidance,
+                init_image_path=state.request.init_image_path,
+                img2img_strength=state.request.img2img_strength,
+                model_variant=state.request.model_variant,
+            )
+
+            def progress_cb(progress: int, message: str) -> None:
+                self._update(job_id, progress=max(1, min(99, progress)), message=message)
+
+            def is_cancelled() -> bool:
+                current = self.get(job_id)
+                return bool(current and current.cancel_requested)
+            selected_provider_id, result = self._generate_with_fallback(
+                requested_model=state.request.model,
+                request=provider_request,
+                output_dir=output_dir,
+                progress_cb=progress_cb,
+                is_cancelled=is_cancelled,
+            )
+            if is_cancelled():
+                self._update(job_id, status=JobStatus.CANCELLED, progress=0, message="Cancelled")
+                return
+            image_paths = [str(path.resolve()) for path in result.image_paths]
+            meta = {
+                "prompt": state.request.prompt,
+                "compiled_prompt": compiled.prompt,
+                "neg_prompt": state.request.negative_prompt,
+                "compiled_neg_prompt": compiled.negative_prompt,
+                "seed": seed,
+                "model": state.request.model,
+                "size": state.request.size,
+                "count": state.request.count,
+                "steps": state.request.steps,
+                "guidance": state.request.guidance,
+                "image_type": state.request.image_type,
+                "style_preset": state.request.style_preset,
+                "style_strength": state.request.style_strength,
+                "init_image_path": state.request.init_image_path,
+                "img2img_strength": state.request.img2img_strength,
+                "model_variant": state.request.model_variant,
+                "requested_model": state.request.model,
+                "used_provider": selected_provider_id,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "images": image_paths,
+            }
+            stable_blob = json.dumps(
+                {
+                    "compiled_prompt": compiled.prompt,
+                    "compiled_neg_prompt": compiled.negative_prompt,
+                    "model": selected_provider_id,
+                    "size": state.request.size,
+                    "steps": state.request.steps,
+                    "guidance": state.request.guidance,
+                    "seed": seed,
+                },
+                sort_keys=True,
+            ).encode("utf-8")
+            meta["config_hash"] = hashlib.sha256(stable_blob).hexdigest()
+            meta_path = output_dir / "meta.json"
+            meta_path.write_text(json.dumps(meta, indent=2), encoding="utf-8")
+            self._update(
+                job_id,
+                status=JobStatus.DONE,
+                progress=100,
+                message="Generation complete",
+                image_paths=image_paths,
+                output_dir=str(output_dir.resolve()),
+            )
+            LOGGER.info("Job %s completed with %s image(s)", job_id, len(image_paths))
+            self._save_state()
+        except Exception as exc:  # noqa: BLE001
+            LOGGER.exception("Job %s failed", job_id)
+            self._update(
+                job_id,
+                status=JobStatus.ERROR,
+                progress=0,
+                message="Generation failed",
+                error=str(exc),
+                output_dir=str(output_dir.resolve()),
+            )
+            self._save_state()
+
+    def _generate_with_fallback(
+        self,
+        requested_model: str,
+        request: ProviderRequest,
+        output_dir: Path,
+        progress_cb,
+        is_cancelled,
+    ) -> tuple[str, ProviderResult]:
+        candidates = self._candidate_models(requested_model)
+        failures: list[str] = []
+
+        for idx, model_id in enumerate(candidates):
+            provider = self.provider_registry.get(model_id)
+            if not provider.is_available():
+                failures.append(f"{model_id}: unavailable")
+                continue
+
+            adjusted_request = request
+            if idx > 0:
+                adjusted_request = self._adjust_request_for_fallback(model_id, request)
+                progress_cb(2, f"Fallback to '{model_id}'")
+            else:
+                progress_cb(2, f"Using provider '{model_id}'")
+
+            try:
+                result = self._generate_with_timeout(
+                    provider=provider,
+                    request=adjusted_request,
+                    output_dir=output_dir,
+                    progress_cb=progress_cb,
+                    is_cancelled=is_cancelled,
+                    timeout_seconds=self._timeout_for_attempt(idx),
+                )
+                if getattr(result, "image_paths", None):
+                    return model_id, result
+                failures.append(f"{model_id}: produced no images")
+            except Exception as exc:  # noqa: BLE001
+                failures.append(f"{model_id}: {exc}")
+
+        raise ProviderUnavailableError(
+            "No provider could generate images. Attempts: " + " | ".join(failures)
+        )
+
+    def _candidate_models(self, requested_model: str) -> list[str]:
+        known = {provider.id for provider in self.provider_registry.list()}
+        if requested_model not in known:
+            raise KeyError(f"Unknown provider: {requested_model}")
+
+        auto_fallback = os.getenv("IMAGEFORGE_ENABLE_AUTO_FALLBACK", "1") == "1"
+        if not auto_fallback:
+            return [requested_model]
+
+        # Try localai and diffusion first (real models), fallback to dummy if needed
+        fallback_raw = os.getenv("IMAGEFORGE_FALLBACK_MODELS", "localai,diffusion,a1111,dummy")
+        fallback_order = [part.strip() for part in fallback_raw.split(",") if part.strip()]
+
+        models: list[str] = [requested_model]
+        for model_id in fallback_order:
+            if model_id in known and model_id not in models:
+                models.append(model_id)
+        return models
+
+    @staticmethod
+    def _timeout_for_attempt(attempt_index: int) -> int:
+        if attempt_index == 0:
+            return JOB_TIMEOUT_SECONDS
+        fallback_timeout = int(os.getenv("IMAGEFORGE_FALLBACK_TIMEOUT_SECONDS", "90"))
+        return max(10, fallback_timeout)
+
+    @staticmethod
+    def _adjust_request_for_fallback(model_id: str, request: ProviderRequest) -> ProviderRequest:
+        max_steps = int(os.getenv("IMAGEFORGE_FALLBACK_MAX_STEPS", "24"))
+        capped_steps = max(1, min(request.steps, max_steps))
+        capped_guidance = min(request.guidance, 8.0)
+        max_side = int(os.getenv("IMAGEFORGE_FALLBACK_MAX_SIDE", "768"))
+        width = min(request.width, max_side)
+        height = min(request.height, max_side)
+        width = max(64, (width // 8) * 8)
+        height = max(64, (height // 8) * 8)
+        return ProviderRequest(
+            prompt=request.prompt,
+            negative_prompt=request.negative_prompt,
+            count=request.count,
+            width=width,
+            height=height,
+            seed=request.seed,
+            steps=capped_steps,
+            guidance=capped_guidance,
+            init_image_path=request.init_image_path,
+            img2img_strength=request.img2img_strength,
+            model_variant=request.model_variant if model_id in {"a1111", "localai", "diffusion"} else None,
+        )
+
+    @staticmethod
+    def _parse_size(size: str) -> tuple[int, int]:
+        try:
+            width_raw, height_raw = size.split("x", maxsplit=1)
+            width = int(width_raw)
+            height = int(height_raw)
+        except Exception as exc:  # noqa: BLE001
+            raise ValueError(f"Invalid size format: {size}") from exc
+        if (width, height) not in {(512, 512), (768, 768), (1024, 1024), (1024, 1536), (1536, 1024)}:
+            raise ValueError(f"Unsupported size: {size}")
+        return width, height
+
+    @staticmethod
+    def _generate_with_timeout(provider, request, output_dir, progress_cb, is_cancelled, timeout_seconds):  # noqa: ANN001
+        result_holder: dict[str, object] = {}
+        error_holder: dict[str, Exception] = {}
+
+        def _run() -> None:
+            try:
+                result_holder["value"] = provider.generate(request, output_dir, progress_cb, is_cancelled)
+            except Exception as exc:  # noqa: BLE001
+                error_holder["error"] = exc
+
+        worker = threading.Thread(target=_run, daemon=True)
+        worker.start()
+
+        started = time.monotonic()
+        while worker.is_alive():
+            if is_cancelled():
+                break
+            if timeout_seconds > 0 and (time.monotonic() - started) > timeout_seconds:
+                raise TimeoutError(
+                    f"Generation timed out after {timeout_seconds}s. "
+                    "Try model 'dummy' or reduce steps/size."
+                )
+            worker.join(timeout=0.5)
+
+        if "error" in error_holder:
+            raise error_holder["error"]
+        if "value" not in result_holder:
+            raise RuntimeError("Generation was interrupted before producing a result")
+        return result_holder["value"]
+
+    def _save_state(self) -> None:
+        rows = []
+        with self._lock:
+            for state in self._jobs.values():
+                rows.append(
+                    {
+                        "job_id": state.job_id,
+                        "request": state.request.model_dump(),
+                        "status": state.status.value,
+                        "progress": state.progress,
+                        "message": state.message,
+                        "created_at": state.created_at.isoformat(),
+                        "updated_at": state.updated_at.isoformat(),
+                        "image_paths": state.image_paths,
+                        "output_dir": state.output_dir,
+                        "error": state.error,
+                        "cancel_requested": state.cancel_requested,
+                    }
+                )
+        self._state_file.parent.mkdir(parents=True, exist_ok=True)
+        payload = json.dumps(rows, indent=2)
+
+        with self._state_write_lock:
+            tmp_path = self._state_file.with_suffix(f"{self._state_file.suffix}.{uuid.uuid4().hex}.tmp")
+            try:
+                tmp_path.write_text(payload, encoding="utf-8")
+                tmp_path.replace(self._state_file)
+            except OSError as exc:
+                LOGGER.warning("State persistence failed (%s). Continuing without crash.", exc)
+                try:
+                    self._state_file.write_text(payload, encoding="utf-8")
+                except OSError as fallback_exc:
+                    LOGGER.warning("Direct state write failed (%s).", fallback_exc)
+            finally:
+                tmp_path.unlink(missing_ok=True)
+
+    def _load_state(self) -> None:
+        if not self._state_file.exists():
+            return
+        try:
+            rows = json.loads(self._state_file.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            return
+        if not isinstance(rows, list):
+            return
+        for row in rows:
+            try:
+                req = GenerateRequest(**row["request"])
+                status = JobStatus(row.get("status", "error"))
+                # Recover queued/running jobs as error on restart to avoid silent loss.
+                if status in {JobStatus.QUEUED, JobStatus.RUNNING}:
+                    status = JobStatus.ERROR
+                    row["error"] = "Recovered after restart during unfinished execution"
+                state = JobState(
+                    job_id=row["job_id"],
+                    request=req,
+                    status=status,
+                    progress=int(row.get("progress", 0)),
+                    message=row.get("message", ""),
+                    created_at=datetime.fromisoformat(row["created_at"]),
+                    updated_at=datetime.fromisoformat(row["updated_at"]),
+                    image_paths=list(row.get("image_paths", [])),
+                    output_dir=row.get("output_dir"),
+                    error=row.get("error"),
+                    cancel_requested=bool(row.get("cancel_requested", False)),
+                )
+                self._jobs[state.job_id] = state
+            except Exception:  # noqa: BLE001
+                continue

imageforge/backend/app/local_ai/__init__.py

@@ -0,0 +1 @@
+

imageforge/backend/app/local_ai/engine.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass
+
+LOGGER = logging.getLogger(__name__)
+
+# Lazy imports to avoid torch loading issues on Windows
+torch = None
+StableDiffusionImg2ImgPipeline = None
+StableDiffusionPipeline = None
+
+def _ensure_imports():
+    global torch, StableDiffusionImg2ImgPipeline, StableDiffusionPipeline
+    if torch is not None:
+        return
+    try:
+        import torch as _torch
+        from diffusers import StableDiffusionImg2ImgPipeline as _Img2Img
+        from diffusers import StableDiffusionPipeline as _Pipeline
+        torch = _torch
+        StableDiffusionImg2ImgPipeline = _Img2Img
+        StableDiffusionPipeline = _Pipeline
+        LOGGER.info("✓ torch and diffusers imported successfully")
+    except Exception as exc:  # pragma: no cover - optional dependency
+        LOGGER.error("✗ Failed to import torch/diffusers: %s", exc, exc_info=True)
+        pass
+
+
+@dataclass(slots=True)
+class LocalAIRequest:
+    prompt: str
+    negative_prompt: str
+    width: int
+    height: int
+    steps: int
+    guidance: float
+    seed: int
+    init_image_path: str | None = None
+    strength: float = 0.45
+    model_variant: str | None = None
+
+
+class LocalAIEngine:
+    """Self-hosted local generation engine; no external API calls required."""
+
+    def __init__(self) -> None:
+        self.model_id = os.getenv("IMAGEFORGE_LOCALAI_MODEL", "segmind/tiny-sd")
+        self._pipe_t2i = None
+        self._pipe_i2i = None
+
+    def is_available(self) -> bool:
+        _ensure_imports()
+        return StableDiffusionPipeline is not None and torch is not None
+
+    def _ensure(self):
+        _ensure_imports()
+        if not self.is_available():
+            raise RuntimeError(
+                "LocalAI dependencies missing. Install diffusers, torch, transformers, accelerate."
+            )
+        if self._pipe_t2i is None:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            dtype = torch.float16 if device == "cuda" else torch.float32
+            local_only = os.getenv("IMAGEFORGE_LOCALAI_LOCAL_ONLY", "0") == "1"
+            LOGGER.info("Loading LocalAI model '%s' on %s", self.model_id, device)
+            try:
+                # FORCE local_files_only=False to allow download if needed
+                pipe = StableDiffusionPipeline.from_pretrained(
+                    self.model_id,
+                    torch_dtype=dtype,
+                    local_files_only=False,  # Always allow download
+                    use_safetensors=True if "safetensors" in self.model_id else None,
+                )
+            except Exception as exc:  # noqa: BLE001
+                LOGGER.error("Failed to load model '%s': %s", self.model_id, exc)
+                raise RuntimeError(
+                    f"LocalAI model '{self.model_id}' could not be loaded. Error: {exc}"
+                ) from exc
+            if device == "cuda":
+                pipe = pipe.to(device)
+                if os.getenv("IMAGEFORGE_ENABLE_ATTENTION_SLICING", "1") == "1":
+                    pipe.enable_attention_slicing()
+            self._pipe_t2i = pipe
+            if StableDiffusionImg2ImgPipeline is not None:
+                pipe_i2i = StableDiffusionImg2ImgPipeline.from_pretrained(
+                    self.model_id,
+                    torch_dtype=dtype,
+                    local_files_only=local_only,
+                )
+                if device == "cuda":
+                    pipe_i2i = pipe_i2i.to(device)
+                    if os.getenv("IMAGEFORGE_ENABLE_ATTENTION_SLICING", "1") == "1":
+                        pipe_i2i.enable_attention_slicing()
+                self._pipe_i2i = pipe_i2i
+        return self._pipe_t2i
+
+    def generate(self, req: LocalAIRequest):
+        from PIL import Image
+
+        if getattr(req, "model_variant", None) and req.model_variant != self.model_id:
+            self.model_id = req.model_variant
+            self._pipe_t2i = None
+            self._pipe_i2i = None
+        pipe = self._ensure()
+        generator = torch.Generator(device=pipe.device).manual_seed(req.seed)
+        if req.init_image_path and self._pipe_i2i is not None:
+            init_img = Image.open(req.init_image_path).convert("RGB").resize((req.width, req.height))
+            out = self._pipe_i2i(
+                prompt=req.prompt,
+                negative_prompt=req.negative_prompt or None,
+                image=init_img,
+                guidance_scale=req.guidance,
+                num_inference_steps=req.steps,
+                strength=max(0.0, min(1.0, req.strength)),
+                generator=generator,
+            )
+        else:
+            out = pipe(
+                prompt=req.prompt,
+                negative_prompt=req.negative_prompt or None,
+                width=req.width,
+                height=req.height,
+                guidance_scale=req.guidance,
+                num_inference_steps=req.steps,
+                generator=generator,
+            )
+        return out.images[0]

imageforge/backend/app/main.py

@@ -0,0 +1,437 @@
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+from fastapi import FastAPI, Header, HTTPException, Query, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, PlainTextResponse
+from PIL import Image
+import uvicorn
+
+from .api.schemas import (
+    AdminSettings,
+    CancelResponse,
+    DashboardStats,
+    ExportRequest,
+    ExportResponse,
+    GenerateRequest,
+    GenerateResponse,
+    HealthResponse,
+    HistoryItem,
+    JobInfoResponse,
+    MetricsResponse,
+    ModelInfo,
+    PresetPayload,
+    PresetResponse,
+    RetryResponse,
+)
+from .core.config import (
+    ADMIN_TOKEN,
+    CONTENT_PROFILE,
+    CORS_ORIGINS,
+    DEFAULT_BACKEND_HOST,
+    DEFAULT_BACKEND_PORT,
+    OUTPUT_DIR,
+    OUTPUT_RETENTION_DAYS,
+    REQUEST_MAX_BYTES,
+)
+from .core.logging import setup_logging
+from .core.observability import MetricsStore
+from .core.policy import ContentPolicy, PolicyAuditStore
+from .core.security import ApiSecurity, Principal
+from .jobs.manager import JobManager
+from .providers.factory import ProviderRegistry
+from .storage.history import PromptHistoryStore
+from .storage.maintenance import cleanup_outputs
+from .storage.presets import PresetStore
+from .storage.settings import SettingsStore
+
+setup_logging()
+LOGGER = logging.getLogger(__name__)
+
+provider_registry = ProviderRegistry()
+history_store = PromptHistoryStore()
+job_manager = JobManager(provider_registry, history_store)
+policy_audit = PolicyAuditStore()
+api_security = ApiSecurity()
+preset_store = PresetStore()
+settings_store = SettingsStore()
+metrics = MetricsStore()
+
+cleanup_removed = cleanup_outputs(OUTPUT_RETENTION_DAYS)
+if cleanup_removed:
+    LOGGER.info("Startup cleanup removed %s old output day folder(s)", cleanup_removed)
+
+app = FastAPI(title="ImageForge Backend", version="0.3.0")
+allow_origins = [item.strip() for item in CORS_ORIGINS.split(",")] if CORS_ORIGINS != "*" else ["*"]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allow_origins,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.middleware("http")
+async def request_limits_middleware(request: Request, call_next):
+    length = request.headers.get("content-length")
+    if length and int(length) > REQUEST_MAX_BYTES:
+        raise HTTPException(status_code=413, detail="Request too large")
+    start = time.perf_counter()
+    response = await call_next(request)
+    elapsed_ms = (time.perf_counter() - start) * 1000.0
+    metrics.incr("http_requests_total")
+    metrics.observe_ms("http_request", elapsed_ms)
+    response.headers["X-Content-Type-Options"] = "nosniff"
+    response.headers["X-Frame-Options"] = "DENY"
+    response.headers["Referrer-Policy"] = "no-referrer"
+    response.headers["Content-Security-Policy"] = "default-src 'self'"
+    return response
+
+
+def _principal(
+    http_request: Request,
+    x_imageforge_api_key: str | None,
+    minimum_role: str,
+) -> Principal:
+    api_security.limit = int(settings_store.get().get("rate_limit_per_minute", api_security.limit))
+    principal = api_security.authenticate(
+        api_key=x_imageforge_api_key,
+        client_id=http_request.client.host if http_request.client else "unknown",
+    )
+    api_security.require_role(principal, minimum_role)
+    return principal
+
+
+@app.get("/health", response_model=HealthResponse)
+def health() -> HealthResponse:
+    return HealthResponse(status="ok", timestamp=datetime.now(timezone.utc))
+
+
+@app.get("/ready", response_model=HealthResponse)
+def ready() -> HealthResponse:
+    try:
+        OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+        probe = OUTPUT_DIR / ".ready_probe"
+        probe.write_text("ok", encoding="utf-8")
+        probe.unlink(missing_ok=True)
+    except Exception as exc:  # noqa: BLE001
+        raise HTTPException(status_code=503, detail=f"Output directory not writable: {exc}") from exc
+    return HealthResponse(status="ready", timestamp=datetime.now(timezone.utc))
+
+
+@app.get("/metrics", response_model=MetricsResponse)
+def metrics_json(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> MetricsResponse:
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    return MetricsResponse(metrics=metrics.snapshot())
+
+
+@app.get("/metrics/prometheus")
+def metrics_prom(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> PlainTextResponse:
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    return PlainTextResponse(metrics.to_prometheus())
+
+
+@app.get("/models", response_model=list[ModelInfo])
+def models(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> list[ModelInfo]:
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    runtime = settings_store.get()
+    adult_enabled = bool(runtime.get("adult_enabled", False))
+    return [
+        ModelInfo(
+            id=provider.id,
+            name=provider.name,
+            description=provider.description,
+            available=provider.is_available() if provider.id != "zimageturbo" else (adult_enabled and provider.is_available()),
+        )
+        for provider in provider_registry.list()
+    ]
+
+
+@app.post("/generate", response_model=GenerateResponse)
+def generate(
+    request: GenerateRequest,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+    x_imageforge_admin_token: str | None = Header(default=None, alias="X-ImageForge-Admin-Token"),
+) -> GenerateResponse:
+    _principal(http_request, x_imageforge_api_key, "operator")
+    try:
+        provider_registry.get(request.model)
+    except KeyError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    runtime = settings_store.get()
+    if request.model == "zimageturbo" and not bool(runtime.get("adult_enabled", False)):
+        raise HTTPException(status_code=400, detail="Adult provider is disabled in admin settings")
+    policy = ContentPolicy(runtime.get("content_profile", CONTENT_PROFILE))
+
+    admin_override_applied = bool(
+        request.admin_override and ADMIN_TOKEN and x_imageforge_admin_token == ADMIN_TOKEN
+    )
+    decision = policy.evaluate(
+        f"{request.prompt}\n{request.negative_prompt}",
+        admin_override=admin_override_applied,
+    )
+    policy_audit.write(
+        prompt=request.prompt,
+        negative_prompt=request.negative_prompt,
+        profile=runtime.get("content_profile", CONTENT_PROFILE),
+        decision=decision,
+        client_ip=http_request.client.host if http_request.client else "unknown",
+        model=request.model,
+        admin_override_requested=request.admin_override,
+        admin_override_applied=admin_override_applied,
+    )
+    if not decision.allowed:
+        raise HTTPException(status_code=400, detail=f"Blocked by policy: {decision.reason}")
+
+    metrics.incr("jobs_submitted_total")
+    job_id = job_manager.submit(request)
+    return GenerateResponse(job_id=job_id)
+
+
+@app.get("/jobs/{job_id}", response_model=JobInfoResponse)
+def job_status(
+    job_id: str,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> JobInfoResponse:
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    state = job_manager.get(job_id)
+    if state is None:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return _to_job_response(state)
+
+
+@app.get("/jobs", response_model=list[JobInfoResponse])
+def list_jobs(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> list[JobInfoResponse]:
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    return [_to_job_response(state) for state in job_manager.list()]
+
+
+@app.get("/image")
+def get_image(path: str = Query(...)) -> FileResponse:
+    try:
+        source = Path(path).resolve(strict=True)
+    except FileNotFoundError as exc:
+        raise HTTPException(status_code=404, detail="Image not found") from exc
+
+    output_root = OUTPUT_DIR.resolve()
+    if source != output_root and output_root not in source.parents:
+        raise HTTPException(status_code=403, detail="Forbidden source path")
+    if not source.is_file():
+        raise HTTPException(status_code=404, detail="Image not found")
+    return FileResponse(source)
+
+
+@app.post("/jobs/{job_id}/retry", response_model=RetryResponse)
+def retry_job(
+    job_id: str,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> RetryResponse:
+    _principal(http_request, x_imageforge_api_key, "operator")
+    new_id = job_manager.retry(job_id)
+    if not new_id:
+        raise HTTPException(status_code=404, detail="Job not found")
+    metrics.incr("jobs_retry_total")
+    return RetryResponse(old_job_id=job_id, new_job_id=new_id)
+
+
+def _to_job_response(state) -> JobInfoResponse:  # noqa: ANN001
+    return JobInfoResponse(
+        job_id=state.job_id,
+        status=state.status,
+        progress=state.progress,
+        message=state.message,
+        created_at=state.created_at,
+        updated_at=state.updated_at,
+        image_paths=state.image_paths,
+        output_dir=state.output_dir,
+        error=state.error,
+    )
+
+
+@app.post("/jobs/{job_id}/cancel", response_model=CancelResponse)
+def cancel(
+    job_id: str,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> CancelResponse:
+    _principal(http_request, x_imageforge_api_key, "operator")
+    success = job_manager.cancel(job_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Job not found")
+    metrics.incr("jobs_cancel_total")
+    return CancelResponse(success=True)
+
+
+@app.get("/history", response_model=list[HistoryItem])
+def history(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> list[HistoryItem]:
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    items = history_store.list()
+    parsed: list[HistoryItem] = []
+    for item in items:
+        try:
+            parsed.append(
+                HistoryItem(
+                    prompt=item.get("prompt", ""),
+                    negative_prompt=item.get("negative_prompt", ""),
+                    timestamp=datetime.fromisoformat(item.get("timestamp", "")),
+                )
+            )
+        except Exception:  # noqa: BLE001
+            continue
+    return parsed
+
+
+@app.get("/dashboard/stats", response_model=DashboardStats)
+def dashboard_stats(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> DashboardStats:
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    return DashboardStats(**job_manager.stats())
+
+
+@app.get("/presets", response_model=list[PresetResponse])
+def list_presets(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> list[PresetResponse]:
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    return [PresetResponse(**asdict(preset)) for preset in preset_store.list()]
+
+
+@app.post("/presets", response_model=PresetResponse)
+def upsert_preset(
+    payload: PresetPayload,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> PresetResponse:
+    _principal(http_request, x_imageforge_api_key, "operator")
+    preset = preset_store.upsert(payload.model_dump())
+    return PresetResponse(**asdict(preset))
+
+
+@app.delete("/presets/{name}", response_model=CancelResponse)
+def delete_preset(
+    name: str,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> CancelResponse:
+    _principal(http_request, x_imageforge_api_key, "admin")
+    ok = preset_store.delete(name)
+    if not ok:
+        raise HTTPException(status_code=404, detail="Preset not found")
+    return CancelResponse(success=True)
+
+
+@app.post("/export", response_model=ExportResponse)
+def export_image(
+    payload: ExportRequest,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> ExportResponse:
+    _principal(http_request, x_imageforge_api_key, "operator")
+    source = Path(payload.source_path).resolve()
+    output_root = OUTPUT_DIR.resolve()
+    if output_root not in source.parents:
+        raise HTTPException(status_code=403, detail="Forbidden source path")
+    if not source.exists() or not source.is_file():
+        raise HTTPException(status_code=404, detail="Source image not found")
+    img = Image.open(source).convert("RGB")
+    if payload.max_width or payload.max_height:
+        max_w = payload.max_width or img.width
+        max_h = payload.max_height or img.height
+        img.thumbnail((max_w, max_h))
+    out_path = source.with_name(f"{source.stem}_export.{payload.format}")
+    save_kwargs: dict[str, int] = {}
+    if payload.format in {"jpg", "webp"}:
+        save_kwargs["quality"] = payload.quality
+    img.save(out_path, format=payload.format.upper(), **save_kwargs)
+    return ExportResponse(output_path=str(out_path.resolve()))
+
+
+@app.get("/admin/settings", response_model=AdminSettings)
+def get_admin_settings(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> AdminSettings:
+    principal = _principal(http_request, x_imageforge_api_key, "admin")
+    current = settings_store.get()
+    metrics.incr(f"admin_settings_read_by_{principal.role}")
+    return AdminSettings(**current)
+
+
+@app.put("/admin/settings", response_model=AdminSettings)
+def put_admin_settings(
+    payload: AdminSettings,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> AdminSettings:
+    principal = _principal(http_request, x_imageforge_api_key, "admin")
+    current = settings_store.update(payload.model_dump(), actor=principal.client_id)
+    return AdminSettings(**current)
+
+
+@app.post("/admin/cleanup", response_model=DashboardStats)
+def cleanup_endpoint(
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+) -> DashboardStats:
+    _principal(http_request, x_imageforge_api_key, "admin")
+    runtime = settings_store.get()
+    cleanup_outputs(int(runtime.get("output_retention_days", OUTPUT_RETENTION_DAYS)))
+    return DashboardStats(**job_manager.stats())
+
+
+@app.get("/files/{relative_path:path}")
+def output_file(
+    relative_path: str,
+    http_request: Request,
+    x_imageforge_api_key: str | None = Header(default=None, alias="X-ImageForge-Api-Key"),
+):
+    _principal(http_request, x_imageforge_api_key, "viewer")
+    path = (Path.cwd() / relative_path).resolve()
+    output_root = OUTPUT_DIR.resolve()
+    if output_root not in path.parents and path != output_root:
+        raise HTTPException(status_code=403, detail="Forbidden")
+    if not path.exists() or not path.is_file():
+        raise HTTPException(status_code=404, detail="File not found")
+    return FileResponse(path)
+
+
+def run() -> None:
+    uvicorn.run(
+        "backend.app.main:app",
+        host=DEFAULT_BACKEND_HOST,
+        port=DEFAULT_BACKEND_PORT,
+        reload=False,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    LOGGER.info("Starting ImageForge backend")
+    run()

imageforge/backend/app/providers/__init__.py

@@ -0,0 +1 @@
+

imageforge/backend/app/providers/a1111_provider.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import base64
+import json
+from pathlib import Path
+import time
+from urllib import error, request
+
+from ..core.config import (
+    A1111_API_AUTH,
+    A1111_API_PASSWORD,
+    A1111_API_USER,
+    A1111_BASE_URL,
+    A1111_HEALTH_ENDPOINT,
+    A1111_RETRY_BACKOFF_SECONDS,
+    A1111_RETRY_COUNT,
+    A1111_TIMEOUT_SECONDS,
+)
+from .interface import ProviderRequest, ProviderResult, ProviderUnavailableError
+
+
+class A1111Provider:
+    id = "a1111"
+    name = "AUTOMATIC1111"
+    description = "Uses AUTOMATIC1111 Stable Diffusion WebUI API"
+
+    def __init__(self) -> None:
+        self.base_url = A1111_BASE_URL.rstrip("/")
+        self.timeout = A1111_TIMEOUT_SECONDS
+        self.health_endpoint = self._normalize_endpoint(A1111_HEALTH_ENDPOINT)
+        self.retry_count = max(0, A1111_RETRY_COUNT)
+        self.retry_backoff_seconds = max(0.0, A1111_RETRY_BACKOFF_SECONDS)
+        self.auth_header = self._resolve_auth_header()
+
+    def is_available(self) -> bool:
+        try:
+            self._request_json("GET", self.health_endpoint, retries=0)
+            return True
+        except Exception:
+            return False
+
+    def generate(self, request_data: ProviderRequest, output_dir: Path, progress, is_cancelled) -> ProviderResult:
+        if not self.is_available():
+            raise ProviderUnavailableError(
+                "AUTOMATIC1111 API not reachable. Start webui with --api and verify IMAGEFORGE_A1111_BASE_URL."
+            )
+        if is_cancelled():
+            return ProviderResult(image_paths=[])
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        progress(5, "AUTOMATIC1111 request started")
+
+        payload = {
+            "prompt": request_data.prompt,
+            "negative_prompt": request_data.negative_prompt or "",
+            "steps": request_data.steps,
+            "cfg_scale": request_data.guidance,
+            "seed": request_data.seed,
+            "width": request_data.width,
+            "height": request_data.height,
+            "batch_size": request_data.count,
+            "n_iter": 1,
+            "sampler_name": "Euler a",
+        }
+
+        if request_data.model_variant:
+            self._request_json("POST", "/sdapi/v1/options", {"sd_model_checkpoint": request_data.model_variant})
+
+        endpoint = "/sdapi/v1/txt2img"
+        if request_data.init_image_path:
+            init_path = Path(request_data.init_image_path)
+            if not init_path.exists() or not init_path.is_file():
+                raise ValueError("init_image_path does not exist or is not a file")
+            payload = {
+                "prompt": request_data.prompt,
+                "negative_prompt": request_data.negative_prompt or "",
+                "steps": request_data.steps,
+                "cfg_scale": request_data.guidance,
+                "seed": request_data.seed,
+                "width": request_data.width,
+                "height": request_data.height,
+                "batch_size": request_data.count,
+                "n_iter": 1,
+                "denoising_strength": max(0.0, min(1.0, request_data.img2img_strength)),
+                "init_images": [base64.b64encode(init_path.read_bytes()).decode("ascii")],
+                "sampler_name": "Euler a",
+            }
+            endpoint = "/sdapi/v1/img2img"
+
+        response = self._request_json("POST", endpoint, payload)
+        images = response.get("images") if isinstance(response, dict) else None
+        if not isinstance(images, list) or not images:
+            raise RuntimeError("AUTOMATIC1111 returned no images")
+
+        image_paths: list[Path] = []
+        total = len(images)
+        for idx, encoded in enumerate(images, start=1):
+            if is_cancelled():
+                break
+            try:
+                raw = base64.b64decode(encoded)
+            except Exception as exc:
+                raise RuntimeError("Failed to decode image from AUTOMATIC1111") from exc
+            out_path = output_dir / f"image_{idx:02d}.png"
+            out_path.write_bytes(raw)
+            image_paths.append(out_path)
+            pct = int((idx / max(1, total)) * 100)
+            progress(pct, f"AUTOMATIC1111 image {idx}/{total} complete")
+
+        return ProviderResult(image_paths=image_paths)
+
+    def _request_json(self, method: str, endpoint: str, payload: dict | None = None, retries: int | None = None):
+        endpoint = self._normalize_endpoint(endpoint)
+        retry_budget = self.retry_count if retries is None else max(0, retries)
+        data = json.dumps(payload).encode("utf-8") if payload is not None else None
+        req = request.Request(
+            f"{self.base_url}{endpoint}",
+            data=data,
+            method=method,
+            headers=self._headers(),
+        )
+
+        attempts = retry_budget + 1
+        for attempt in range(1, attempts + 1):
+            try:
+                with request.urlopen(req, timeout=self.timeout) as resp:
+                    return json.loads(resp.read().decode("utf-8"))
+            except error.HTTPError as exc:
+                detail = exc.read().decode("utf-8", errors="ignore")
+                retryable = exc.code >= 500 or exc.code == 429
+                if retryable and attempt < attempts:
+                    self._sleep_before_retry(attempt)
+                    continue
+                raise RuntimeError(f"AUTOMATIC1111 {method} failed ({exc.code}): {detail}") from exc
+            except Exception as exc:
+                if attempt < attempts:
+                    self._sleep_before_retry(attempt)
+                    continue
+                raise RuntimeError(f"AUTOMATIC1111 {method} failed: {exc}") from exc
+
+    def _headers(self) -> dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.auth_header:
+            headers["Authorization"] = self.auth_header
+        return headers
+
+    @staticmethod
+    def _normalize_endpoint(endpoint: str) -> str:
+        if endpoint.startswith("/"):
+            return endpoint
+        return f"/{endpoint}"
+
+    def _resolve_auth_header(self) -> str:
+        if A1111_API_AUTH.strip():
+            token = base64.b64encode(A1111_API_AUTH.encode("utf-8")).decode("ascii")
+            return f"Basic {token}"
+        if A1111_API_USER.strip() or A1111_API_PASSWORD.strip():
+            pair = f"{A1111_API_USER}:{A1111_API_PASSWORD}"
+            token = base64.b64encode(pair.encode("utf-8")).decode("ascii")
+            return f"Basic {token}"
+        return ""
+
+    def _sleep_before_retry(self, attempt: int) -> None:
+        if self.retry_backoff_seconds <= 0:
+            return
+        time.sleep(self.retry_backoff_seconds * attempt)

imageforge/backend/app/providers/diffusion_provider.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+from .interface import ProviderRequest, ProviderResult, ProviderUnavailableError
+
+LOGGER = logging.getLogger(__name__)
+
+# Lazy imports to avoid torch loading issues on Windows
+torch = None
+StableDiffusionImg2ImgPipeline = None
+StableDiffusionPipeline = None
+
+def _ensure_imports():
+    global torch, StableDiffusionImg2ImgPipeline, StableDiffusionPipeline
+    if torch is not None:
+        return
+    try:
+        import torch as _torch
+        from diffusers import StableDiffusionImg2ImgPipeline as _Img2Img
+        from diffusers import StableDiffusionPipeline as _Pipeline
+        torch = _torch
+        StableDiffusionImg2ImgPipeline = _Img2Img
+        StableDiffusionPipeline = _Pipeline
+    except Exception:  # pragma: no cover - optional dependency
+        pass
+
+
+class DiffusionProvider:
+    id = "diffusion"
+    name = "Stable Diffusion (local)"
+    description = "Uses diffusers for local Stable Diffusion generation"
+
+    def __init__(self, model_id: str = "segmind/tiny-sd") -> None:
+        self.model_id = os.getenv("IMAGEFORGE_DIFFUSION_MODEL", model_id)
+        self._pipe: StableDiffusionPipeline | None = None
+        self._img2img_pipe: StableDiffusionImg2ImgPipeline | None = None
+
+    def is_available(self) -> bool:
+        _ensure_imports()
+        return StableDiffusionPipeline is not None and torch is not None
+
+    def _ensure_pipeline(self) -> StableDiffusionPipeline:
+        _ensure_imports()
+        if StableDiffusionPipeline is None or torch is None:
+            raise ProviderUnavailableError(
+                "Diffusion dependencies missing. Install diffusers, torch, and transformers."
+            )
+        if self._pipe is None:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            dtype = torch.float16 if device == "cuda" else torch.float32
+            local_only = os.getenv("IMAGEFORGE_DIFFUSION_LOCAL_ONLY", "0") == "1"
+            LOGGER.info("Loading diffusion model '%s' on %s", self.model_id, device)
+            try:
+                pipe = StableDiffusionPipeline.from_pretrained(
+                    self.model_id,
+                    torch_dtype=dtype,
+                    local_files_only=local_only,
+                )
+            except Exception as exc:  # noqa: BLE001
+                mode_hint = "local cache only" if local_only else "online download"
+                raise ProviderUnavailableError(
+                    f"Diffusion model '{self.model_id}' could not be loaded ({mode_hint}). "
+                    "Set IMAGEFORGE_DIFFUSION_LOCAL_ONLY=0 to allow downloading models."
+                ) from exc
+            if device == "cuda":
+                pipe = pipe.to(device)
+                if os.getenv("IMAGEFORGE_ENABLE_ATTENTION_SLICING", "1") == "1":
+                    pipe.enable_attention_slicing()
+            self._pipe = pipe
+        return self._pipe
+
+    def _ensure_img2img_pipeline(self) -> StableDiffusionImg2ImgPipeline | None:
+        _ensure_imports()
+        if StableDiffusionImg2ImgPipeline is None or torch is None:
+            return None
+        if self._img2img_pipe is None:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            dtype = torch.float16 if device == "cuda" else torch.float32
+            local_only = os.getenv("IMAGEFORGE_DIFFUSION_LOCAL_ONLY", "0") == "1"
+            LOGGER.info("Loading diffusion img2img model '%s' on %s", self.model_id, device)
+            try:
+                img2img = StableDiffusionImg2ImgPipeline.from_pretrained(
+                    self.model_id,
+                    torch_dtype=dtype,
+                    local_files_only=local_only,
+                )
+            except Exception as exc:  # noqa: BLE001
+                mode_hint = "local cache only" if local_only else "online download"
+                raise ProviderUnavailableError(
+                    f"Diffusion img2img model '{self.model_id}' could not be loaded ({mode_hint}). "
+                    "Set IMAGEFORGE_DIFFUSION_LOCAL_ONLY=0 to allow downloading models."
+                ) from exc
+            if device == "cuda":
+                img2img = img2img.to(device)
+                if os.getenv("IMAGEFORGE_ENABLE_ATTENTION_SLICING", "1") == "1":
+                    img2img.enable_attention_slicing()
+            self._img2img_pipe = img2img
+        return self._img2img_pipe
+
+    def generate(self, request: ProviderRequest, output_dir: Path, progress, is_cancelled) -> ProviderResult:
+        if is_cancelled():
+            return ProviderResult(image_paths=[])
+        if request.model_variant and request.model_variant != self.model_id:
+            self.model_id = request.model_variant
+            self._pipe = None
+            self._img2img_pipe = None
+        progress(1, "Loading diffusion model")
+        pipe = self._ensure_pipeline()
+        output_dir.mkdir(parents=True, exist_ok=True)
+        image_paths: list[Path] = []
+
+        for idx in range(request.count):
+            if is_cancelled():
+                break
+
+            seed = request.seed + idx
+            generator = torch.Generator(device=pipe.device).manual_seed(seed)
+
+            def _callback(step: int, timestep: int, latents):  # noqa: ANN001
+                if is_cancelled():
+                    raise RuntimeError("Generation cancelled")
+                local_progress = int(((step + 1) / max(1, request.steps)) * 100)
+                progress(local_progress, f"Diffusion step {step + 1}/{request.steps} (image {idx + 1})")
+
+            if request.init_image_path:
+                from PIL import Image
+
+                img2img_pipe = self._ensure_img2img_pipeline()
+                if img2img_pipe is None:
+                    raise ProviderUnavailableError("Img2Img requires diffusers img2img pipeline support")
+                init_image = Image.open(request.init_image_path).convert("RGB").resize((request.width, request.height))
+                result = img2img_pipe(
+                    prompt=request.prompt,
+                    negative_prompt=request.negative_prompt or None,
+                    image=init_image,
+                    num_inference_steps=request.steps,
+                    guidance_scale=request.guidance,
+                    strength=max(0.0, min(1.0, request.img2img_strength)),
+                    generator=generator,
+                    callback=_callback,
+                    callback_steps=1,
+                )
+            else:
+                result = pipe(
+                    prompt=request.prompt,
+                    negative_prompt=request.negative_prompt or None,
+                    width=request.width,
+                    height=request.height,
+                    num_inference_steps=request.steps,
+                    guidance_scale=request.guidance,
+                    generator=generator,
+                    callback=_callback,
+                    callback_steps=1,
+                )
+            image = result.images[0]
+            image_path = output_dir / f"image_{idx + 1:02d}.png"
+            image.save(image_path, format="PNG")
+            image_paths.append(image_path)
+            pct = int(((idx + 1) / request.count) * 100)
+            progress(pct, f"Diffusion image {idx + 1}/{request.count} complete")
+
+        return ProviderResult(image_paths=image_paths)

imageforge/backend/app/providers/dummy_provider.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+from .interface import IImageProvider, ProviderRequest, ProviderResult
+
+
+class DummyProvider(IImageProvider):
+    id = "dummy"
+    name = "Dummy Placeholder"
+    description = "Generates local placeholder images without AI dependencies"
+
+    def is_available(self) -> bool:
+        return True
+
+    def generate(
+        self,
+        request: ProviderRequest,
+        output_dir: Path,
+        progress,
+        is_cancelled,
+    ) -> ProviderResult:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        image_paths: list[Path] = []
+
+        for idx in range(request.count):
+            if is_cancelled():
+                break
+
+            image = Image.new("RGB", (request.width, request.height))
+            pixels = image.load()
+            for y in range(request.height):
+                for x in range(request.width):
+                    r = int(40 + 215 * (x / max(1, request.width - 1)))
+                    g = int(40 + 215 * (y / max(1, request.height - 1)))
+                    b = int(120 + 80 * math.sin((x + y) / 120))
+                    pixels[x, y] = (r, g, max(0, min(255, b)))
+            if request.init_image_path:
+                source = Image.open(request.init_image_path).convert("RGB")
+                source = source.resize((request.width, request.height))
+                alpha = max(0.0, min(1.0, request.img2img_strength))
+                image = Image.blend(source, image, 1.0 - alpha)
+
+            draw = ImageDraw.Draw(image)
+            font = ImageFont.load_default()
+            lines = [
+                f"DummyProvider #{idx + 1}",
+                f"Prompt: {request.prompt[:80]}",
+                f"Negative: {request.negative_prompt[:80] or '-'}",
+                f"Seed: {request.seed}",
+                f"Size: {request.width}x{request.height}",
+            ]
+            y_pos = 20
+            for line in lines:
+                draw.rectangle((16, y_pos - 2, request.width - 16, y_pos + 14), fill=(0, 0, 0))
+                draw.text((20, y_pos), line, fill=(255, 255, 255), font=font)
+                y_pos += 20
+
+            image_path = output_dir / f"image_{idx + 1:02d}.png"
+            image.save(image_path, format="PNG")
+            image_paths.append(image_path)
+            pct = int(((idx + 1) / request.count) * 100)
+            progress(pct, f"Dummy image {idx + 1}/{request.count} complete")
+
+        return ProviderResult(image_paths=image_paths)

imageforge/backend/app/providers/factory.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from .a1111_provider import A1111Provider
+from .diffusion_provider import DiffusionProvider
+from .dummy_provider import DummyProvider
+from .interface import IImageProvider
+from .localai_provider import LocalAIProvider
+from .zimageturbo_provider import ZImageTurboProvider
+
+
+class ProviderRegistry:
+    def __init__(self) -> None:
+        self._providers: dict[str, IImageProvider] = {
+            "dummy": DummyProvider(),
+            "localai": LocalAIProvider(),
+            "diffusion": DiffusionProvider(),
+            "a1111": A1111Provider(),
+            "zimageturbo": ZImageTurboProvider(),
+        }
+
+    def get(self, provider_id: str) -> IImageProvider:
+        provider = self._providers.get(provider_id)
+        if provider is None:
+            raise KeyError(f"Unknown provider: {provider_id}")
+        return provider
+
+    def list(self) -> list[IImageProvider]:
+        return list(self._providers.values())

imageforge/backend/app/providers/huggingface_provider.py

@@ -0,0 +1,328 @@
+"""
+HuggingFace Spaces Provider for PixelForge
+
+This provider allows PixelForge to call any HuggingFace Space as an image generation backend.
+Supports both Spaces with Gradio API and custom inference endpoints.
+
+Phase 2 Implementation (Future)
+"""
+
+import os
+import json
+import requests
+import base64
+import logging
+from io import BytesIO
+from pathlib import Path
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+
+class HuggingFaceSpaceProvider:
+    """
+    Provider für HuggingFace Spaces Integration
+    
+    Beispiele:
+    - Heartsync/Adult: Erwachsene Bildgenerierung (Z-Image Turbo)
+    - Andere Spaces: beliebige Custom Spaces
+    
+    Umgebungsvariablen:
+    - HF_API_TOKEN: HuggingFace API Token (https://huggingface.co/settings/tokens)
+    - HF_SPACE_URL: Komplette Space URL oder nur "username/space-name"
+    - HF_REQUEST_TIMEOUT: Timeout in Sekunden (default: 300)
+    """
+    
+    id = "huggingface"
+    name = "HuggingFace Spaces"
+    description = "Nutzt HuggingFace Spaces für Image Generation (erwachsene Inhalte, Anime, Custom)"
+    
+    def __init__(
+        self,
+        space_id: str = None,
+        api_token: str = None,
+        timeout: int = 300,
+    ):
+        """
+        Args:
+            space_id: HuggingFace Space ID (z.B. "Heartsync/Adult" oder komplette URL)
+            api_token: HuggingFace API Token
+            timeout: Request Timeout in Sekunden
+        """
+        self.space_id = space_id or os.getenv("HF_SPACE_URL", "Heartsync/Adult")
+        self.api_token = api_token or os.getenv("HF_API_TOKEN", "")
+        self.timeout = timeout or int(os.getenv("HF_REQUEST_TIMEOUT", "300"))
+        
+        # Normalize space URL
+        if not self.space_id.startswith("https://"):
+            self.space_id = f"https://huggingface.co/spaces/{self.space_id}"
+        
+        self.api_url = f"{self.space_id}/call/predict"
+        self.logger = logging.getLogger(__name__)
+    
+    def is_available(self) -> bool:
+        """Check if HuggingFace Space is reachable"""
+        if not self.api_token:
+            self.logger.warning("HF_API_TOKEN not set - HuggingFace Space Provider unavailable")
+            return False
+        
+        try:
+            # Check Space health
+            response = requests.head(
+                self.space_id,
+                timeout=5,
+                headers={"Authorization": f"Bearer {self.api_token}"}
+            )
+            is_available = response.status_code < 500
+            if is_available:
+                self.logger.info(f"✓ HuggingFace Space verfügbar: {self.space_id}")
+            else:
+                self.logger.warning(f"HuggingFace Space Status: {response.status_code}")
+            return is_available
+        except Exception as e:
+            self.logger.error(f"HuggingFace Space Health Check failed: {e}")
+            return False
+    
+    def generate(self, request: "ProviderRequest") -> "ProviderResult":
+        """
+        Generate image using HuggingFace Space
+        
+        Args:
+            request: ProviderRequest mit prompt, negative_prompt, etc.
+        
+        Returns:
+            ProviderResult mit generiertem Bild
+        """
+        try:
+            # Payload für Gradio Space API
+            payload = {
+                "data": [
+                    request.prompt,           # prompt
+                    request.negative_prompt,  # negative_prompt
+                    int(request.seed % (2**31)),  # seed
+                    request.steps,            # num_inference_steps
+                    request.guidance_scale,   # guidance_scale
+                ]
+            }
+            
+            headers = {
+                "Authorization": f"Bearer {self.api_token}",
+                "Content-Type": "application/json",
+            }
+            
+            self.logger.info(f"Generating image on HF Space: {self.space_id}")
+            self.logger.debug(f"Payload: {json.dumps(payload, indent=2)}")
+            
+            # Call HuggingFace Space
+            response = requests.post(
+                self.api_url,
+                json=payload,
+                headers=headers,
+                timeout=self.timeout,
+            )
+            
+            response.raise_for_status()
+            
+            # Parse response
+            result = response.json()
+            self.logger.debug(f"HF Response: {json.dumps(result, indent=2)}")
+            
+            # Erwartete Struktur: {"data": [{"name": "image.png", "data": "base64..."}]}
+            if "data" not in result or not result["data"]:
+                raise ValueError(f"Unexpected response format: {result}")
+            
+            # Extract image(s) from response
+            image_data_list = result["data"]
+            if not isinstance(image_data_list, list):
+                image_data_list = [image_data_list]
+            
+            image_paths = []
+            
+            for idx, img_data in enumerate(image_data_list):
+                # Handle different response formats
+                if isinstance(img_data, dict) and "data" in img_data:
+                    # Gradio format: {"name": "...", "data": "base64..."}
+                    base64_str = img_data["data"]
+                elif isinstance(img_data, str):
+                    # Direct base64 string
+                    base64_str = img_data
+                else:
+                    self.logger.warning(f"Unknown image format: {type(img_data)}")
+                    continue
+                
+                # Decode base64 image
+                if base64_str.startswith("data:image"):
+                    # Data URL format: "data:image/png;base64,..."
+                    base64_str = base64_str.split(",", 1)[1]
+                
+                try:
+                    image_bytes = base64.b64decode(base64_str)
+                    image = Image.open(BytesIO(image_bytes))
+                    
+                    # Save to disk
+                    output_path = Path(__file__).parent.parent.parent / "output" / f"image_{idx:02d}.png"
+                    output_path.parent.mkdir(parents=True, exist_ok=True)
+                    image.save(output_path)
+                    
+                    image_paths.append(str(output_path))
+                    self.logger.info(f"✓ Image saved: {output_path}")
+                    
+                except Exception as e:
+                    self.logger.error(f"Failed to decode/save image {idx}: {e}")
+                    raise
+            
+            if not image_paths:
+                raise ValueError("No images in response")
+            
+            return {
+                "image_paths": image_paths,
+                "message": f"Generated {len(image_paths)} image(s) via {self.space_id}",
+            }
+        
+        except requests.Timeout:
+            raise TimeoutError(
+                f"HuggingFace Space request timed out after {self.timeout}s. "
+                "Space might be busy or overloaded."
+            )
+        except requests.HTTPError as e:
+            if e.response.status_code == 401:
+                raise PermissionError(f"Invalid HF API Token")
+            elif e.response.status_code == 404:
+                raise ValueError(f"HuggingFace Space not found: {self.space_id}")
+            else:
+                raise RuntimeError(f"HF Space API error: {e}")
+        except Exception as e:
+            self.logger.error(f"HuggingFace Space generation failed: {e}")
+            raise
+
+
+# ============================================================================
+# Alternative: Verwendung von gradio_client statt REST
+# ============================================================================
+
+class HuggingFaceSpaceProviderGradio:
+    """
+    Alternative Implementation using gradio_client
+    
+    Vorteil: Automatische Format-Konvertierung
+    Nachteil: Zusätzliche Dependency (gradio-client)
+    
+    Usage:
+        pip install gradio_client
+    """
+    
+    id = "huggingface_gradio"
+    name = "HuggingFace Spaces (Gradio)"
+    description = "HuggingFace Spaces via Gradio Client"
+    
+    def __init__(self, space_id: str = None):
+        try:
+            from gradio_client import Client
+            self.Client = Client
+        except ImportError:
+            raise ImportError("gradio-client not installed. Install with: pip install gradio_client")
+        
+        self.space_id = space_id or os.getenv("HF_SPACE_URL", "Heartsync/Adult")
+        self.logger = logging.getLogger(__name__)
+    
+    def is_available(self) -> bool:
+        try:
+            client = self.Client(f"https://huggingface.co/spaces/{self.space_id}")
+            self.logger.info(f"✓ Gradio Client verbunden: {self.space_id}")
+            return True
+        except Exception as e:
+            self.logger.error(f"Gradio Client connection failed: {e}")
+            return False
+    
+    def generate(self, request: "ProviderRequest") -> "ProviderResult":
+        from gradio_client import Client
+        
+        try:
+            client = Client(f"https://huggingface.co/spaces/{self.space_id}")
+            
+            result = client.predict(
+                prompt=request.prompt,
+                negative_prompt=request.negative_prompt,
+                seed=int(request.seed % (2**31)),
+                num_inference_steps=request.steps,
+                guidance_scale=request.guidance_scale,
+                api_name="/predict"
+            )
+            
+            # Gradio returns file path
+            image_path = str(result)
+            
+            return {
+                "image_paths": [image_path],
+                "message": f"Generated via {self.space_id}",
+            }
+        
+        except Exception as e:
+            self.logger.error(f"Gradio generation failed: {e}")
+            raise
+
+
+# ============================================================================
+# Integration Instructions for later
+# ============================================================================
+
+"""
+INTEGRATION CHECKLIST (Phase 2):
+
+1. ✅ Dieses File erstellt
+2. [ ] HuggingFace API Token besorgen:
+       - https://huggingface.co/settings/tokens
+       - New Token → read role
+       - Setze env: HF_API_TOKEN=hf_xxxxx
+
+3. [ ] Adult_repo zu HF Space deployen:
+       - cd d:/VSC Codes/Bild/Adult_repo
+       - pip install huggingface-hub
+       - huggingface-cli login
+       - git push huggingface main
+
+4. [ ] Provider in Factory registrieren:
+       # in imageforge/backend/app/providers/factory.py
+       from .huggingface_provider import HuggingFaceSpaceProvider
+       
+       _providers = {
+           ...
+           "huggingface": HuggingFaceSpaceProvider(),
+       }
+
+5. [ ] Testen:
+       # Im Backend
+       POST http://127.0.0.1:8008/generate
+       {
+           "model": "huggingface",
+           "prompt": "A beautiful sunset",
+           "negative_prompt": "",
+           "steps": 20,
+           "guidance_scale": 7.5
+       }
+
+6. [ ] Colab deaktivieren oder als Fallback nutzen
+
+TROUBLESHOOTING:
+
+Problem: "HF_API_TOKEN not set"
+Fix: $env:HF_API_TOKEN = "hf_xxxxx"; Restart Backend
+
+Problem: "Space not found (404)"
+Fix: Space-ID prüfen: "Heartsync/Adult" oder komplette URL?
+
+Problem: "Request timeout"
+Fix: Space ist überlastet. Später erneut versuchen.
+     Oder: $env:HF_REQUEST_TIMEOUT = "600"  (10 Min)
+
+Problem: "Invalid API Token"
+Fix: Token regenerieren auf https://huggingface.co/settings/tokens
+     Ensure read permissions
+
+TESTEN MIT CURL:
+
+curl -X POST https://api-inference.huggingface.co/models/Heartsync/Adult \\
+  -H "Authorization: Bearer hf_xxxxx" \\
+  -H "Content-Type: application/json" \\
+  -d '{"inputs": "a girl in school uniform"}'
+"""

imageforge/backend/app/providers/interface.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Protocol
+
+
+class ProviderUnavailableError(RuntimeError):
+    pass
+
+
+@dataclass(slots=True)
+class ProviderRequest:
+    prompt: str
+    negative_prompt: str
+    count: int
+    width: int
+    height: int
+    seed: int
+    steps: int
+    guidance: float
+    init_image_path: str | None = None
+    img2img_strength: float = 0.45
+    model_variant: str | None = None
+
+
+@dataclass(slots=True)
+class ProviderResult:
+    image_paths: list[Path]
+
+
+ProgressCallback = Callable[[int, str], None]
+CancelCallback = Callable[[], bool]
+
+
+class IImageProvider(Protocol):
+    id: str
+    name: str
+    description: str
+
+    def is_available(self) -> bool:
+        ...
+
+    def generate(
+        self,
+        request: ProviderRequest,
+        output_dir: Path,
+        progress: ProgressCallback,
+        is_cancelled: CancelCallback,
+    ) -> ProviderResult:
+        ...

imageforge/backend/app/providers/localai_provider.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import threading
+import time
+
+from ..local_ai.engine import LocalAIEngine, LocalAIRequest
+from .interface import ProviderRequest, ProviderResult, ProviderUnavailableError
+
+
+class LocalAIProvider:
+    id = "localai"
+    name = "LocalAI (self-hosted)"
+    description = "Own local AI engine, no paid cloud API required"
+
+    def __init__(self) -> None:
+        self.engine = LocalAIEngine()
+        self.image_timeout_seconds = max(1, int(os.getenv("IMAGEFORGE_LOCALAI_IMAGE_TIMEOUT_SECONDS", "180")))
+
+    def is_available(self) -> bool:
+        return self.engine.is_available()
+
+    def generate(self, request: ProviderRequest, output_dir: Path, progress, is_cancelled) -> ProviderResult:
+        if not self.is_available():
+            raise ProviderUnavailableError(
+                "LocalAI dependencies missing. Install diffusers/torch packages."
+            )
+        output_dir.mkdir(parents=True, exist_ok=True)
+        image_paths: list[Path] = []
+
+        for idx in range(request.count):
+            if is_cancelled():
+                break
+            progress(5, f"LocalAI preparing image {idx + 1}/{request.count}")
+            image = self._generate_with_heartbeat(
+                LocalAIRequest(
+                    prompt=request.prompt,
+                    negative_prompt=request.negative_prompt,
+                    width=request.width,
+                    height=request.height,
+                    steps=request.steps,
+                    guidance=request.guidance,
+                    seed=request.seed + idx,
+                    init_image_path=request.init_image_path,
+                    strength=request.img2img_strength,
+                    model_variant=request.model_variant,
+                ),
+                progress=progress,
+                is_cancelled=is_cancelled,
+                image_index=idx + 1,
+                total=request.count,
+            )
+            image_path = output_dir / f"image_{idx + 1:02d}.png"
+            image.save(image_path, format="PNG")
+            image_paths.append(image_path)
+            pct = int(((idx + 1) / request.count) * 100)
+            progress(pct, f"LocalAI image {idx + 1}/{request.count} complete")
+
+        return ProviderResult(image_paths=image_paths)
+
+    def _generate_with_heartbeat(
+        self,
+        request: LocalAIRequest,
+        progress,
+        is_cancelled,
+        image_index: int,
+        total: int,
+    ):
+        result_holder: dict[str, object] = {}
+        error_holder: dict[str, Exception] = {}
+
+        def _run() -> None:
+            try:
+                result_holder["image"] = self.engine.generate(request)
+            except Exception as exc:  # noqa: BLE001
+                error_holder["error"] = exc
+
+        worker = threading.Thread(target=_run, daemon=True)
+        worker.start()
+
+        started = time.monotonic()
+        heartbeat = 8
+        while worker.is_alive():
+            if is_cancelled():
+                raise RuntimeError("Generation cancelled")
+            elapsed = time.monotonic() - started
+            if elapsed > self.image_timeout_seconds:
+                raise TimeoutError(
+                    "LocalAI generation timed out. "
+                    "Try fewer steps/smaller size or use fallback model 'dummy'."
+                )
+            pct = min(95, heartbeat)
+            progress(
+                pct,
+                f"LocalAI generating image {image_index}/{total} ({pct}%, {int(elapsed)}s)",
+            )
+            heartbeat = min(95, heartbeat + 2)
+            worker.join(timeout=1.0)
+
+        if "error" in error_holder:
+            raise error_holder["error"]
+        if "image" not in result_holder:
+            raise RuntimeError("LocalAI generation ended without image result")
+        return result_holder["image"]

imageforge/backend/app/providers/zimageturbo_provider.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import os
+import time
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+from urllib.parse import urljoin
+
+import requests
+from PIL import Image
+
+from .interface import (
+    CancelCallback,
+    IImageProvider,
+    ProgressCallback,
+    ProviderRequest,
+    ProviderResult,
+    ProviderUnavailableError,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+
+class ZImageTurboProvider(IImageProvider):
+    id = "zimageturbo"
+    name = "Adult + Z-Image Turbo (HF Space API)"
+    description = "Nutzen von Heartsync/Adult per HuggingFace Space API"
+
+    def __init__(self) -> None:
+        self.mode = os.getenv("ZIMAGETURBO_MODE", "hf_space").strip().lower()
+        self.api_key = os.getenv("ZIMAGETURBO_API_KEY", "").strip()
+        self.timeout = int(os.getenv("ZIMAGETURBO_TIMEOUT", "300"))
+
+        self.hf_space = os.getenv("ZIMAGETURBO_HF_SPACE", "Heartsync/Adult").strip()
+        self.hf_api_name = os.getenv("ZIMAGETURBO_HF_API_NAME", "predict").strip().lstrip("/")
+
+        legacy_base = os.getenv("ZIMAGETURBO_API_URL", "").strip()
+        if legacy_base:
+            self.legacy_api_url = legacy_base.rstrip("/")
+        else:
+            self.legacy_api_url = ""
+
+        self.hf_base_url = f"https://huggingface.co/spaces/{self.hf_space}"
+        self._available: bool | None = None
+
+    def is_available(self) -> bool:
+        if self._available is not None:
+            return self._available
+        try:
+            if self.mode == "legacy":
+                self._available = self._is_legacy_available()
+            else:
+                self._available = self._is_hf_space_available()
+        except Exception:  # noqa: BLE001
+            self._available = False
+        return self._available
+
+    def generate(
+        self,
+        request: ProviderRequest,
+        output_dir: Path,
+        progress: ProgressCallback,
+        is_cancelled: CancelCallback,
+    ) -> ProviderResult:
+        if not self.is_available():
+            raise ProviderUnavailableError("Adult + Z-Image Turbo API nicht verfügbar")
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        image_paths: list[Path] = []
+
+        for index in range(request.count):
+            if is_cancelled():
+                break
+
+            progress(int(10 + 80 * (index / max(1, request.count))), f"Generiere Bild {index + 1}/{request.count}...")
+            current_seed = request.seed + index if request.seed >= 0 else None
+
+            if self.mode == "legacy":
+                image = self._generate_legacy(request, current_seed)
+            else:
+                image = self._generate_hf_space(request, current_seed)
+
+            out = output_dir / f"image_{index + 1:02d}.png"
+            image.save(out)
+            image_paths.append(out)
+            progress(int(10 + 80 * ((index + 1) / max(1, request.count))), f"Bild {index + 1}/{request.count} gespeichert")
+
+        if not image_paths:
+            raise RuntimeError("Keine Bilder erzeugt")
+
+        return ProviderResult(image_paths=image_paths)
+
+    def _headers(self) -> dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    def _is_legacy_available(self) -> bool:
+        if not self.legacy_api_url:
+            return False
+        try:
+            response = requests.get(f"{self.legacy_api_url}/health", timeout=5, headers=self._headers())
+            return response.status_code == 200
+        except Exception as exc:  # noqa: BLE001
+            LOGGER.warning("Legacy ZImageTurbo health failed: %s", exc)
+            return False
+
+    def _is_hf_space_available(self) -> bool:
+        try:
+            response = requests.get(self.hf_base_url, timeout=8)
+            if response.status_code < 500:
+                return True
+            LOGGER.warning("HF Space returned status %s", response.status_code)
+            return False
+        except Exception as exc:  # noqa: BLE001
+            LOGGER.warning("HF Space health failed: %s", exc)
+            return False
+
+    def _generate_legacy(self, request: ProviderRequest, seed: int | None) -> Image.Image:
+        payload: dict[str, Any] = {
+            "prompt": request.prompt,
+            "negative_prompt": request.negative_prompt,
+            "width": request.width,
+            "height": request.height,
+            "num_inference_steps": request.steps,
+            "guidance_scale": request.guidance,
+        }
+        if seed is not None:
+            payload["seed"] = seed
+
+        response = requests.post(
+            f"{self.legacy_api_url}/generate",
+            json=payload,
+            headers=self._headers(),
+            timeout=self.timeout,
+        )
+        response.raise_for_status()
+        body = response.json()
+        if not body.get("success") or not body.get("image"):
+            raise RuntimeError(body.get("error", "Ungültige Legacy API Antwort"))
+        raw = base64.b64decode(body["image"])
+        return Image.open(BytesIO(raw)).convert("RGB")
+
+    def _generate_hf_space(self, request: ProviderRequest, seed: int | None) -> Image.Image:
+        api_call_url = f"{self.hf_base_url}/gradio_api/call/{self.hf_api_name}"
+        payload = {
+            "data": [
+                request.prompt,
+                request.height,
+                request.width,
+                request.steps,
+                seed if seed is not None else 42,
+                seed is None,
+                1,
+            ]
+        }
+
+        call_response = requests.post(
+            api_call_url,
+            json=payload,
+            headers=self._headers(),
+            timeout=self.timeout,
+        )
+        call_response.raise_for_status()
+        call_payload = call_response.json()
+        event_id = call_payload.get("event_id")
+        if not event_id:
+            raise RuntimeError(f"HF Space call failed: {call_payload}")
+
+        result = self._poll_hf_event(event_id)
+        image_url = self._extract_first_image_url(result)
+        if not image_url:
+            raise RuntimeError(f"Kein Bild in HF-Antwort: {result}")
+
+        full_url = image_url if image_url.startswith("http") else urljoin(self.hf_base_url, image_url)
+        image_response = requests.get(full_url, timeout=self.timeout)
+        image_response.raise_for_status()
+        return Image.open(BytesIO(image_response.content)).convert("RGB")
+
+    def _poll_hf_event(self, event_id: str) -> Any:
+        result_url = f"{self.hf_base_url}/gradio_api/call/{self.hf_api_name}/{event_id}"
+        deadline = time.time() + self.timeout
+
+        while time.time() < deadline:
+            response = requests.get(result_url, timeout=30)
+            response.raise_for_status()
+            lines = [line.strip() for line in response.text.splitlines() if line.strip()]
+            data_lines = [line[5:].strip() for line in lines if line.startswith("data:")]
+            if not data_lines:
+                time.sleep(1)
+                continue
+
+            for raw in reversed(data_lines):
+                if raw in {"[DONE]", "null"}:
+                    continue
+                try:
+                    return json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+            time.sleep(1)
+
+        raise TimeoutError(f"HF Space Timeout nach {self.timeout}s")
+
+    def _extract_first_image_url(self, payload: Any) -> str | None:
+        stack = [payload]
+        while stack:
+            item = stack.pop()
+            if isinstance(item, str):
+                if item.startswith("http") and ("/gradio_api/file=" in item or item.endswith((".png", ".jpg", ".jpeg", ".webp"))):
+                    return item
+                if item.startswith("/gradio_api/file="):
+                    return item
+            elif isinstance(item, dict):
+                for key in ("url", "path"):
+                    value = item.get(key)
+                    if isinstance(value, str):
+                        if value.startswith("http") or value.startswith("/gradio_api/file="):
+                            return value
+                stack.extend(item.values())
+            elif isinstance(item, list):
+                stack.extend(item)
+        return None

imageforge/backend/app/storage/__init__.py

@@ -0,0 +1 @@
+

imageforge/backend/app/storage/history.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from threading import Lock
+
+from ..core.config import HISTORY_FILE
+
+
+class PromptHistoryStore:
+    def __init__(self, max_entries: int = 50) -> None:
+        self.max_entries = max_entries
+        self._lock = Lock()
+
+    def add(self, prompt: str, negative_prompt: str) -> None:
+        with self._lock:
+            items = self._read()
+            items.insert(
+                0,
+                {
+                    "prompt": prompt,
+                    "negative_prompt": negative_prompt,
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                },
+            )
+            HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
+            HISTORY_FILE.write_text(
+                json.dumps(items[: self.max_entries], indent=2), encoding="utf-8"
+            )
+
+    def list(self) -> list[dict[str, str]]:
+        with self._lock:
+            return self._read()
+
+    def _read(self) -> list[dict[str, str]]:
+        if not HISTORY_FILE.exists():
+            return []
+        try:
+            raw = json.loads(HISTORY_FILE.read_text(encoding="utf-8"))
+            if isinstance(raw, list):
+                return [item for item in raw if isinstance(item, dict)]
+        except json.JSONDecodeError:
+            return []
+        return []

imageforge/backend/app/storage/maintenance.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from ..core.config import OUTPUT_DIR
+
+
+def cleanup_outputs(retention_days: int) -> int:
+    if retention_days <= 0:
+        return 0
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    cutoff = datetime.now(timezone.utc) - timedelta(days=retention_days)
+    removed = 0
+    for item in OUTPUT_DIR.iterdir():
+        if not item.is_dir():
+            continue
+        dt = _parse_date(item.name)
+        if dt and dt < cutoff:
+            _remove_tree(item)
+            removed += 1
+    return removed
+
+
+def _parse_date(name: str) -> datetime | None:
+    try:
+        return datetime.strptime(name, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+    except ValueError:
+        return None
+
+
+def _remove_tree(path: Path) -> None:
+    for child in path.glob("**/*"):
+        if child.is_file():
+            child.unlink(missing_ok=True)
+    for child in sorted(path.glob("**/*"), reverse=True):
+        if child.is_dir():
+            child.rmdir()
+    path.rmdir()

imageforge/backend/app/storage/presets.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from threading import Lock
+
+from ..core.config import PRESETS_FILE
+
+
+@dataclass(slots=True)
+class Preset:
+    name: str
+    prompt: str
+    negative_prompt: str
+    model: str
+    size: str
+    count: int
+    steps: int
+    guidance: float
+    image_type: str
+    style_preset: str
+    style_strength: int
+    updated_at: str
+
+
+class PresetStore:
+    def __init__(self) -> None:
+        self._lock = Lock()
+
+    def list(self) -> list[Preset]:
+        with self._lock:
+            return [Preset(**item) for item in self._read()]
+
+    def upsert(self, payload: dict) -> Preset:
+        with self._lock:
+            rows = self._read()
+            now = datetime.now(timezone.utc).isoformat()
+            preset = Preset(
+                name=payload["name"],
+                prompt=payload.get("prompt", ""),
+                negative_prompt=payload.get("negative_prompt", ""),
+                model=payload.get("model", "dummy"),
+                size=payload.get("size", "1024x1024"),
+                count=int(payload.get("count", 1)),
+                steps=int(payload.get("steps", 30)),
+                guidance=float(payload.get("guidance", 7.5)),
+                image_type=payload.get("image_type", "general"),
+                style_preset=payload.get("style_preset", "auto"),
+                style_strength=int(payload.get("style_strength", 60)),
+                updated_at=now,
+            )
+            rows = [row for row in rows if row.get("name") != preset.name]
+            rows.insert(0, asdict(preset))
+            self._write(rows)
+            return preset
+
+    def delete(self, name: str) -> bool:
+        with self._lock:
+            rows = self._read()
+            after = [row for row in rows if row.get("name") != name]
+            if len(after) == len(rows):
+                return False
+            self._write(after)
+            return True
+
+    def _read(self) -> list[dict]:
+        if not PRESETS_FILE.exists():
+            return []
+        try:
+            content = json.loads(PRESETS_FILE.read_text(encoding="utf-8"))
+            if isinstance(content, list):
+                return [row for row in content if isinstance(row, dict)]
+        except json.JSONDecodeError:
+            return []
+        return []
+
+    def _write(self, rows: list[dict]) -> None:
+        PRESETS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        PRESETS_FILE.write_text(json.dumps(rows[:200], indent=2), encoding="utf-8")

imageforge/backend/app/storage/settings.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from threading import Lock
+
+from ..core.config import (
+    ADMIN_AUDIT_FILE,
+    CONTENT_PROFILE,
+    OUTPUT_RETENTION_DAYS,
+    RATE_LIMIT_PER_MINUTE,
+    SETTINGS_FILE,
+)
+
+
+DEFAULT_SETTINGS = {
+    "content_profile": CONTENT_PROFILE,
+    "rate_limit_per_minute": RATE_LIMIT_PER_MINUTE,
+    "output_retention_days": OUTPUT_RETENTION_DAYS,
+    "adult_enabled": False,
+}
+
+
+class SettingsStore:
+    def __init__(self) -> None:
+        self._lock = Lock()
+
+    def get(self) -> dict:
+        with self._lock:
+            return self._merged()
+
+    def update(self, patch: dict, actor: str) -> dict:
+        with self._lock:
+            current = self._merged()
+            current.update({k: v for k, v in patch.items() if v is not None})
+            self._write(current)
+            self._audit(actor=actor, patch=patch, current=current)
+            return current
+
+    def _merged(self) -> dict:
+        current = DEFAULT_SETTINGS.copy()
+        current.update(self._read())
+        return current
+
+    def _read(self) -> dict:
+        if not SETTINGS_FILE.exists():
+            return {}
+        try:
+            parsed = json.loads(SETTINGS_FILE.read_text(encoding="utf-8"))
+            return parsed if isinstance(parsed, dict) else {}
+        except json.JSONDecodeError:
+            return {}
+
+    def _write(self, data: dict) -> None:
+        SETTINGS_FILE.parent.mkdir(parents=True, exist_ok=True)
+        SETTINGS_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    def _audit(self, actor: str, patch: dict, current: dict) -> None:
+        entry = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "actor": actor,
+            "patch": patch,
+            "current": current,
+        }
+        ADMIN_AUDIT_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with ADMIN_AUDIT_FILE.open("a", encoding="utf-8") as fp:
+            fp.write(json.dumps(entry, ensure_ascii=True) + "\n")

imageforge/backend/tests/test_a1111_provider.py

@@ -0,0 +1,51 @@
+import base64
+
+from backend.app.providers.a1111_provider import A1111Provider
+
+
+class _FakeResponse:
+    def __init__(self, payload: bytes) -> None:
+        self._payload = payload
+
+    def read(self) -> bytes:
+        return self._payload
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+
+def test_a1111_provider_builds_auth_header_from_compact_auth(monkeypatch) -> None:
+    monkeypatch.setattr("backend.app.providers.a1111_provider.A1111_API_AUTH", "user:secret")
+    monkeypatch.setattr("backend.app.providers.a1111_provider.A1111_API_USER", "")
+    monkeypatch.setattr("backend.app.providers.a1111_provider.A1111_API_PASSWORD", "")
+
+    provider = A1111Provider()
+
+    assert provider.auth_header.startswith("Basic ")
+    encoded = provider.auth_header.split(" ", maxsplit=1)[1]
+    decoded = base64.b64decode(encoded.encode("ascii")).decode("utf-8")
+    assert decoded == "user:secret"
+
+
+def test_a1111_provider_retries_transient_failure(monkeypatch) -> None:
+    monkeypatch.setattr("backend.app.providers.a1111_provider.A1111_RETRY_COUNT", 2)
+    monkeypatch.setattr("backend.app.providers.a1111_provider.A1111_RETRY_BACKOFF_SECONDS", 0.0)
+
+    attempts = {"count": 0}
+
+    def fake_urlopen(req, timeout):  # noqa: ANN001
+        attempts["count"] += 1
+        if attempts["count"] == 1:
+            raise OSError("temporary network issue")
+        return _FakeResponse(b'{"ok": true}')
+
+    monkeypatch.setattr("backend.app.providers.a1111_provider.request.urlopen", fake_urlopen)
+
+    provider = A1111Provider()
+    result = provider._request_json("GET", "/sdapi/v1/sd-models")
+
+    assert result == {"ok": True}
+    assert attempts["count"] == 2