Spaces:

mrsavage1
/

mofh-api-proxy

Running

App Files Files Community

mofh-api-proxy / app.py

mrsavage1

Upload 15 files

dcf70a0 verified 12 days ago

raw

history blame contribute delete

105 kB

	from fastapi import FastAPI, HTTPException, Response, Request
	from fastapi.responses import HTMLResponse
	from pydantic import BaseModel, validator
	import requests
	import os
	import base64
	import json
	from typing import Optional, List
	import random
	import time
	from datetime import datetime
	import psutil
	import logging

	# Configure logging
	logging.basicConfig(level=logging.INFO)
	logger = logging.getLogger(__name__)

	def update_deployment_status(repo_owner, repo_name, workflow_run_id, status, conclusion=None, workflow_url=None):
	"""Forward deployment status to VistaPanel Backend API"""
	try:
	payload = {
	'repo_owner': repo_owner,
	'repo_name': repo_name,
	'workflow_run_id': workflow_run_id,
	'status': status,
	'conclusion': conclusion,
	'workflow_url': workflow_url
	}

	# The VistaPanel endpoint URL
	api_url = os.getenv('CELESTINE_API_URL', 'https://celestine.indevs.in/api/webhook-receiver.php')
	secret = os.getenv('WEBHOOK_SECRET', 'savage')

	headers = {
	'X-Celestine-Secret': secret,
	'Content-Type': 'application/json',
	'User-Agent': 'Celestine-HF-Space/1.0'
	}

	logger.info(f"📤 Forwarding to VistaPanel: {api_url}")
	logger.info(f" Payload: {json.dumps(payload, indent=2)}")

	# Increase timeout and add retry logic
	response = requests.post(
	api_url,
	json=payload,
	headers=headers,
	timeout=15,
	allow_redirects=True
	)

	logger.info(f" Response Status: {response.status_code}")
	logger.info(f" Response Body: {response.text[:200]}")

	if response.status_code == 200:
	logger.info(f"✓ Forwarded status to Celestine: {repo_owner}/{repo_name} -> {status}")
	return True
	else:
	logger.error(f"Failed to forward status: HTTP {response.status_code} - {response.text}")
	return False
	except requests.exceptions.Timeout:
	logger.error(f"Webhook forwarding timeout after 15s")
	return False
	except requests.exceptions.ConnectionError as e:
	logger.error(f"Webhook forwarding connection error: {e}")
	return False
	except Exception as e:
	logger.error(f"Webhook forwarding error: {e}")
	return False

	app = FastAPI(title="MOFH API Proxy + IONA AI")

	# Track uptime
	START_TIME = time.time()
	REQUEST_COUNT = {"total": 0, "generate": 0, "create": 0, "errors": 0}

	# High-quality image library for professional websites
	WEBSITE_IMAGES = [

	"https://images.unsplash.com/photo-1497366754035-f200968a6e72?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1497366811353-6870744d04b2?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1497215728101-856f4ea42174?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1497366216548-37526070297c?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1441986300917-64674bd600d8?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1486406146926-c627a92ad1ab?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1504384308090-c894fdcc538d?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1517245386807-bb43f82c33c4?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1519389950473-47ba0277781c?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1542744094-24638eff58bb?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1460925895917-afdab827c52f?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1522202176988-66273c2fd55f?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1552664730-d307ca884978?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1531482615713-2afd69097998?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1498050108023-c5249f4df085?auto=format&fit=crop&q=80&w=1920&h=1080",
	"https://images.unsplash.com/photo-1516321318423-f06f85e504b3?auto=format&fit=crop&q=80&w=1920&h=1080"
	]

	def get_random_images(count=10):
	"""Get random images from the library"""
	return random.sample(WEBSITE_IMAGES, min(count, len(WEBSITE_IMAGES)))

	MOFH_API_URL = "https://panel.myownfreehost.net:2087/xml-api/"
	MOFH_API_USERNAME = "ZqHK1H5BBnrrywnsXXW2pY42QNqDxHru74HtwZofkn1LRawd4TDcKCPnIViBiPaJg1sUXUlKErn4EhXmqu0vx1STF263TxiTQuyKzYcErjSax5W4lBoLXqpE0aQqnLLKi8Pk7fncTbcfwqnKVRNOzLd34xdakdiHH1Z4gmDbetSmYauCId4Cj8SVizSBTuN6TMIrz2oMKAoXPypSocVOOUI0rSOIld34MY6yXtcHdSgh3Jd5J8mgM8SiW8BvHtE"
	MOFH_API_PASSWORD = "Uj39SyF5okKP73Ml6laLEay40MZEXSe81lStBEc9dQC2odK49Tw4K5l4BXI3DfnIVA5ZoIH0GFKvBRBO1cLIU1djjSBCABBkp2GO2oeH4BROw238dZwODu0kklR0uezHPfezHMCbcbjSKLRKJX5Ns7gZ9wgXxZbO3e8Rf4MoZnQVk5IUNLvKPWHDP43PsQnAFAYOhDNnKPBBg2CoHXsJ1Kq8C5wRuBd64GPyPhY7sbSCibAMUWKRkUSzRi7aq5i"

	# IONA AI - Multiple API Keys for Load Balancing (No Rate Limits)
	GROQ_API_KEYS = [
	"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", # Replace with real keys
	"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",
	"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",
	"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"
	]

	# Model Configuration - Use ONLY the most capable model
	AI_MODELS = {
	"groq": [
	"llama-3.3-70b-versatile", # Most capable, reliable for complex generation
	]
	}

	# Track API usage for rotation
	api_usage_counter = {key: 0 for key in GROQ_API_KEYS}

	def get_next_api_key():
	"""Round-robin API key selection for load balancing"""
	min_usage_key = min(api_usage_counter, key=api_usage_counter.get)
	api_usage_counter[min_usage_key] += 1
	return min_usage_key

	def get_random_model():
	"""Select model (always use 70B for reliability)"""
	return AI_MODELS["groq"][0] # Always use llama-3.3-70b-versatile

	class AIWebsiteRequest(BaseModel):
	prompt: str
	business_type: Optional[str] = "general"
	color_scheme: Optional[str] = "modern"
	include_database: Optional[bool] = True
	php_only: Optional[bool] = False
	features: Optional[List[str]] = []

	@validator('prompt')
	def validate_prompt(cls, v):
	if not v or len(v.strip()) < 10:
	raise ValueError('Prompt must be at least 10 characters')
	if len(v) > 10000:
	raise ValueError('Prompt too long (max 10000 characters)')
	return v.strip()

	class AccountRequest(BaseModel):
	username: str
	password: str
	email: str
	domain: str
	plan: str = "free"

	@validator('username')
	def validate_username(cls, v):
	if not v or len(v) < 3:
	raise ValueError('Username must be at least 3 characters')
	if len(v) > 20:
	raise ValueError('Username too long (max 20 characters)')
	return v.strip()

	@validator('email')
	def validate_email(cls, v):
	if '@' not in v or '.' not in v:
	raise ValueError('Invalid email format')
	return v.strip()

	@app.get("/", response_class=HTMLResponse)
	def root():
	"""Uptime dashboard with external IP display"""
	import socket

	hostname = socket.gethostname()
	local_ip = socket.gethostbyname(hostname)

	# Get external IP
	try:
	external_ip = requests.get('https://api.ipify.org', timeout=5).text
	except:
	external_ip = "Unable to detect"

	# Calculate uptime
	uptime_seconds = int(time.time() - START_TIME)
	uptime_hours = uptime_seconds // 3600
	uptime_minutes = (uptime_seconds % 3600) // 60
	uptime_secs = uptime_seconds % 60

	# Get system stats
	try:
	cpu_percent = psutil.cpu_percent(interval=1)
	memory = psutil.virtual_memory()
	memory_percent = memory.percent
	memory_used = memory.used / (1024**3) # GB
	memory_total = memory.total / (1024**3) # GB
	except:
	cpu_percent = 0
	memory_percent = 0
	memory_used = 0
	memory_total = 0

	# API key status
	api_key_usage = []
	for key, count in api_usage_counter.items():
	api_key_usage.append(f"{key[:20]}... → {count} requests")

	html_content = f"""
	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>IONA AI - System Status</title>
	<style>
	* {{
	margin: 0;
	padding: 0;
	box-sizing: border-box;
	}}
	body {{
	font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
	min-height: 100vh;
	padding: 20px;
	color: #fff;
	}}
	.container {{
	max-width: 1200px;
	margin: 0 auto;
	}}
	.header {{
	text-align: center;
	margin-bottom: 40px;
	animation: fadeIn 0.5s;
	}}
	.header h1 {{
	font-size: 3rem;
	margin-bottom: 10px;
	text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
	}}
	.header p {{
	font-size: 1.2rem;
	opacity: 0.9;
	}}
	.status-badge {{
	display: inline-block;
	background: #10b981;
	padding: 8px 20px;
	border-radius: 50px;
	font-weight: bold;
	margin-top: 10px;
	box-shadow: 0 4px 6px rgba(0,0,0,0.2);
	animation: pulse 2s infinite;
	}}
	@keyframes pulse {{
	0%, 100% {{ transform: scale(1); }}
	50% {{ transform: scale(1.05); }}
	}}
	@keyframes fadeIn {{
	from {{ opacity: 0; transform: translateY(-20px); }}
	to {{ opacity: 1; transform: translateY(0); }}
	}}
	.grid {{
	display: grid;
	grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
	gap: 20px;
	margin-bottom: 30px;
	}}
	.card {{
	background: rgba(255, 255, 255, 0.1);
	backdrop-filter: blur(10px);
	border-radius: 15px;
	padding: 25px;
	box-shadow: 0 8px 32px rgba(0,0,0,0.2);
	border: 1px solid rgba(255, 255, 255, 0.2);
	animation: fadeIn 0.5s;
	transition: transform 0.3s;
	}}
	.card:hover {{
	transform: translateY(-5px);
	}}
	.card h2 {{
	font-size: 1.5rem;
	margin-bottom: 15px;
	display: flex;
	align-items: center;
	gap: 10px;
	}}
	.card-icon {{
	font-size: 2rem;
	}}
	.stat {{
	display: flex;
	justify-content: space-between;
	padding: 10px 0;
	border-bottom: 1px solid rgba(255, 255, 255, 0.1);
	}}
	.stat:last-child {{
	border-bottom: none;
	}}
	.stat-label {{
	opacity: 0.8;
	}}
	.stat-value {{
	font-weight: bold;
	font-size: 1.1rem;
	}}
	.ip-box {{
	background: rgba(0, 0, 0, 0.3);
	padding: 15px;
	border-radius: 10px;
	margin-top: 15px;
	font-family: 'Courier New', monospace;
	font-size: 1.1rem;
	text-align: center;
	border: 2px solid rgba(255, 255, 255, 0.3);
	}}
	.progress-bar {{
	width: 100%;
	height: 20px;
	background: rgba(0, 0, 0, 0.3);
	border-radius: 10px;
	overflow: hidden;
	margin-top: 10px;
	}}
	.progress-fill {{
	height: 100%;
	background: linear-gradient(90deg, #10b981, #3b82f6);
	transition: width 0.3s;
	display: flex;
	align-items: center;
	justify-content: center;
	font-size: 0.85rem;
	font-weight: bold;
	}}
	.endpoint-list {{
	list-style: none;
	margin-top: 15px;
	}}
	.endpoint-list li {{
	padding: 10px;
	background: rgba(0, 0, 0, 0.2);
	margin-bottom: 8px;
	border-radius: 8px;
	border-left: 4px solid #10b981;
	}}
	.endpoint-method {{
	display: inline-block;
	background: #3b82f6;
	padding: 3px 10px;
	border-radius: 5px;
	font-size: 0.85rem;
	font-weight: bold;
	margin-right: 10px;
	}}
	.footer {{
	text-align: center;
	margin-top: 40px;
	opacity: 0.8;
	}}
	.refresh-btn {{
	background: rgba(255, 255, 255, 0.2);
	border: 2px solid rgba(255, 255, 255, 0.5);
	color: white;
	padding: 12px 30px;
	border-radius: 50px;
	cursor: pointer;
	font-size: 1rem;
	font-weight: bold;
	transition: all 0.3s;
	margin-top: 20px;
	}}
	.refresh-btn:hover {{
	background: rgba(255, 255, 255, 0.3);
	transform: scale(1.05);
	}}
	.api-key-list {{
	font-size: 0.9rem;
	margin-top: 10px;
	}}
	.api-key-list div {{
	padding: 5px;
	background: rgba(0, 0, 0, 0.2);
	margin-bottom: 5px;
	border-radius: 5px;
	font-family: 'Courier New', monospace;
	}}
	</style>
	</head>
	<body>
	<div class="container">
	<div class="header">
	<h1>Celestine Hosting Backend</h1>
	<p>Intelligent Website Generator & MOFH API Proxy</p>
	<div class="status-badge">🟢 ONLINE</div>
	</div>

	<div class="grid">
	<div class="card">
	<h2><span class="card-icon">⏱️</span> Uptime</h2>
	<div class="stat">
	<span class="stat-label">Running Since</span>
	<span class="stat-value">{datetime.fromtimestamp(START_TIME).strftime('%Y-%m-%d %H:%M:%S')}</span>
	</div>
	<div class="stat">
	<span class="stat-label">Uptime</span>
	<span class="stat-value">{uptime_hours}h {uptime_minutes}m {uptime_secs}s</span>
	</div>
	<div class="stat">
	<span class="stat-label">Total Requests</span>
	<span class="stat-value">{REQUEST_COUNT['total']}</span>
	</div>
	<div class="stat">
	<span class="stat-label">Errors</span>
	<span class="stat-value">{REQUEST_COUNT['errors']}</span>
	</div>
	</div>

	<div class="card">
	<h2><span class="card-icon">🌐</span> Network Info</h2>
	<div class="stat">
	<span class="stat-label">Hostname</span>
	<span class="stat-value">{hostname}</span>
	</div>
	<div class="stat">
	<span class="stat-label">Local IP</span>
	<span class="stat-value">{local_ip}</span>
	</div>
	<div class="ip-box">
	<div style="opacity: 0.7; font-size: 0.9rem; margin-bottom: 5px;">External IP Address</div>
	<div style="font-size: 1.3rem; font-weight: bold;">{external_ip}</div>
	</div>
	<div style="margin-top: 15px; padding: 10px; background: rgba(255, 193, 7, 0.2); border-radius: 8px; font-size: 0.85rem;">
	⚠️ Add this IP to MOFH API whitelist
	</div>
	</div>

	<div class="card">
	<h2><span class="card-icon">💻</span> System Resources</h2>
	<div class="stat">
	<span class="stat-label">CPU Usage</span>
	<span class="stat-value">{cpu_percent:.1f}%</span>
	</div>
	<div class="progress-bar">
	<div class="progress-fill" style="width: {cpu_percent}%">{cpu_percent:.1f}%</div>
	</div>
	<div class="stat" style="margin-top: 15px;">
	<span class="stat-label">Memory Usage</span>
	<span class="stat-value">{memory_percent:.1f}%</span>
	</div>
	<div class="progress-bar">
	<div class="progress-fill" style="width: {memory_percent}%">{memory_percent:.1f}%</div>
	</div>
	<div class="stat" style="margin-top: 10px;">
	<span class="stat-label">Memory</span>
	<span class="stat-value">{memory_used:.2f} GB / {memory_total:.2f} GB</span>
	</div>
	</div>
	</div>

	<div class="grid">
	<div class="card">
	<h2><span class="card-icon">🤖</span> AI Configuration</h2>
	<div class="stat">
	<span class="stat-label">Active Models</span>
	<span class="stat-value">{len(AI_MODELS['groq'])}</span>
	</div>
	<div class="stat">
	<span class="stat-label">API Keys</span>
	<span class="stat-value">{len(GROQ_API_KEYS)}</span>
	</div>
	<div class="stat">
	<span class="stat-label">Generations</span>
	<span class="stat-value">{REQUEST_COUNT['generate']}</span>
	</div>
	<div class="api-key-list">
	{''.join([f'<div>{usage}</div>' for usage in api_key_usage])}
	</div>
	</div>

	<div class="card">
	<h2><span class="card-icon">📡</span> API Endpoints</h2>
	<ul class="endpoint-list">
	<li>
	<span class="endpoint-method">GET</span>
	<span>/</span>
	<div style="font-size: 0.85rem; opacity: 0.8; margin-top: 5px;">System status dashboard</div>
	</li>
	<li>
	<span class="endpoint-method">POST</span>
	<span>/generate-website</span>
	<div style="font-size: 0.85rem; opacity: 0.8; margin-top: 5px;">Generate website with IONA AI</div>
	</li>
	<li>
	<span class="endpoint-method">POST</span>
	<span>/create</span>
	<div style="font-size: 0.85rem; opacity: 0.8; margin-top: 5px;">Create MOFH hosting account</div>
	</li>
	<li>
	<span class="endpoint-method">GET</span>
	<span>/health</span>
	<div style="font-size: 0.85rem; opacity: 0.8; margin-top: 5px;">Health check endpoint</div>
	</li>
	<li>
	<span class="endpoint-method">GET</span>
	<span>/test</span>
	<div style="font-size: 0.85rem; opacity: 0.8; margin-top: 5px;">Test AI generation</div>
	</li>
	</ul>
	</div>

	<div class="card">
	<h2><span class="card-icon">👨‍💻</span> Developer Info</h2>
	<div class="stat">
	<span class="stat-label">Developer</span>
	<span class="stat-value">Pratyush Srivastava</span>
	</div>
	<div class="stat">
	<span class="stat-label">GitHub</span>
	<span class="stat-value"><a href="https://github.com/pratyush" style="color: #fff; text-decoration: none;">@pratyush</a></span>
	</div>
	<div class="stat">
	<span class="stat-label">Portfolio</span>
	<span class="stat-value"><a href="https://pratyush.dev" style="color: #fff; text-decoration: none;">pratyush.dev</a></span>
	</div>
	<div class="stat">
	<span class="stat-label">Version</span>
	<span class="stat-value">2026.1.0</span>
	</div>
	</div>
	</div>

	<div style="text-align: center;">
	<button class="refresh-btn" onclick="location.reload()">🔄 Refresh Status</button>
	</div>

	<div class="footer">
	<p>IONA AI - Intelligent Website Generator</p>
	<p style="font-size: 0.9rem; margin-top: 10px;">Powered by Groq AI • FastAPI • Python</p>
	</div>
	</div>

	<script>
	// Auto-refresh every 30 seconds
	setTimeout(() => location.reload(), 30000);
	</script>
	</body>
	</html>
	"""

	return html_content

	@app.get("/health")
	def health_check():
	"""Health check endpoint for monitoring"""
	return {
	"status": "healthy",
	"uptime_seconds": int(time.time() - START_TIME),
	"timestamp": datetime.now().isoformat(),
	"requests": REQUEST_COUNT
	}

	@app.get("/test")
	def test_generation():
	"""Test AI generation with a simple prompt"""
	try:
	api_key = get_next_api_key()
	model = get_random_model()

	test_prompt = "Create a simple HTML page with a heading 'Hello World' and a paragraph."

	headers = {
	"Authorization": f"Bearer {api_key}",
	"Content-Type": "application/json"
	}

	payload = {
	"model": model,
	"messages": [
	{"role": "system", "content": "You are a helpful assistant. Return only valid JSON."},
	{"role": "user", "content": test_prompt}
	],
	"temperature": 0.7,
	"max_tokens": 500
	}

	response = requests.post(
	"https://api.groq.com/openai/v1/chat/completions",
	headers=headers,
	json=payload,
	timeout=30
	)

	if response.status_code == 200:
	result = response.json()
	return {
	"success": True,
	"model": model,
	"response_length": len(result['choices'][0]['message']['content']),
	"tokens_used": result.get('usage', {}),
	"message": "AI is working correctly!"
	}
	else:
	return {
	"success": False,
	"error": f"HTTP {response.status_code}",
	"message": "AI test failed"
	}
	except Exception as e:
	return {
	"success": False,
	"error": str(e),
	"message": "AI test failed with exception"
	}

	@app.post("/generate-website")
	def generate_website(req: AIWebsiteRequest):
	"""IONA AI - Generate complete website with HTML, CSS, JS, and MySQL"""
	REQUEST_COUNT["total"] += 1
	REQUEST_COUNT["generate"] += 1

	try:
	logger.info("=== IONA AI Generation Started ===")
	logger.info(f"Business Type: {req.business_type}")
	logger.info(f"Prompt Length: {len(req.prompt)} chars")
	logger.info(f"PHP Only Mode: {req.php_only}")

	api_key = get_next_api_key()
	model = get_random_model()
	logger.info(f"Model: {model}, API Key: {api_key[:20]}...")

	# Get random images for this website
	selected_images = get_random_images(15)
	images_list = '\n'.join([f"- {img}" for img in selected_images])

	# Check if PHP-only mode
	if req.php_only:
	# PHP-only generation prompt
	system_prompt = f"""You are IONA AI, an expert PHP backend developer.

	🎯 HOSTING ENVIRONMENT: VistaPanel (Free Hosting)
	- PHP Version: 7.4 or 8.0
	- MySQL Database available
	- PDO and MySQLi supported

	🎯 MISSION: Generate ONLY PHP BACKEND FILES (NO HTML/CSS/JS).

	📦 REQUIRED OUTPUT FORMAT:
	Return ONLY a valid JSON object with these keys:
	{{
	"contact_php": "Complete contact form handler with validation and email sending",
	"api_php": "RESTful API endpoints with JSON responses",
	"functions_php": "Helper functions for database, validation, sanitization",
	"config": "Database configuration with PDO connection",
	"sql": "MySQL schema with sample data",
	"readme": "Setup guide for VistaPanel"
	}}

	🐘 PHP FILE REQUIREMENTS:

	1. contact_php (Contact Form Handler):
	- Handle POST requests
	- Validate: name, email, phone, message
	- Sanitize all inputs (htmlspecialchars, filter_var)
	- Send email using mail() function
	- Store in database
	- Return JSON response
	- CSRF protection
	- Rate limiting (session-based)
	- Error handling

	2. api_php (API Endpoints):
	- RESTful structure
	- GET /api.php?action=list (list items)
	- POST /api.php?action=create (create item)
	- PUT /api.php?action=update (update item)
	- DELETE /api.php?action=delete (delete item)
	- JSON responses
	- Authentication (if needed)
	- Input validation
	- Error handling

	3. functions_php (Helper Functions):
	- Database query helpers (select, insert, update, delete)
	- Input validation functions
	- Sanitization functions
	- Email sending function
	- Authentication helpers
	- Session management
	- Error logging

	4. config (Database Configuration):
	- PDO connection setup
	- Database credentials (localhost, username, password, dbname)
	- Error handling (try-catch)
	- Timezone settings
	- Error reporting settings
	- Session configuration

	5. sql (MySQL Schema):
	- CREATE DATABASE statement
	- CREATE TABLE statements
	- Proper data types (VARCHAR, INT, TEXT, DATETIME)
	- Primary keys (AUTO_INCREMENT)
	- Foreign keys and indexes
	- Timestamps (created_at, updated_at)
	- Sample data (5-10 realistic entries)

	PHP SECURITY REQUIREMENTS:
	- Use prepared statements (PDO) for ALL database queries
	- Sanitize ALL user inputs
	- Validate email addresses with filter_var()
	- Use password_hash() for passwords
	- Implement CSRF tokens
	- Use htmlspecialchars() for output
	- Set proper error reporting
	- Use sessions securely

	PHP BEST PRACTICES:
	- PSR-12 coding standards
	- Proper indentation (4 spaces)
	- Clear variable names
	- Comments for complex logic
	- Separate concerns
	- Return JSON for AJAX requests
	- Use HTTP status codes
	- Error handling (try-catch)

	CODE FORMATTING:
	- Proper indentation (4 spaces per level)
	- Blank lines between functions
	- Comments for each function
	- Use \n for newlines in JSON strings

	IMPORTANT JSON RULES:
	- Return ONLY the JSON object
	- NO markdown code blocks
	- NO explanations
	- Escape quotes with backslash
	- Use \n for newlines
	- Do NOT return null values
	- Generate COMPLETE, FUNCTIONAL code

	CREATE PROFESSIONAL PHP BACKEND FOR VISTAPANEL! 🚀"""

	user_prompt = f"""Generate PHP backend files for: {req.prompt}

	Requirements:
	- Complete contact form handler
	- RESTful API endpoints
	- Helper functions
	- Database configuration
	- MySQL schema with sample data

	Return as JSON with contact_php, api_php, functions_php, config, sql, and readme keys."""
	else:
	# Full website generation prompt
	system_prompt = f"""You are IONA AI, an elite full-stack web developer with 15+ years of experience.

	🎯 HOSTING ENVIRONMENT: VistaPanel (Free Hosting)
	- PHP Version: 7.4 or 8.0
	- MySQL Database available
	- File Manager: VistaPanel
	- No SSH access
	- Standard PHP functions available
	- PDO and MySQLi supported

	🎯 MISSION: Generate COMPLETE, PRODUCTION-READY, MULTI-FILE websites with REAL CONTENT.

	📦 REQUIRED OUTPUT FORMAT:
	Return ONLY a valid JSON object with these keys:
	{{
	"html": "Complete HTML5 document with PROPER INDENTATION (2 spaces per level)",
	"css": "Complete CSS with PROPER FORMATTING and line breaks",
	"js": "Complete JavaScript with PROPER FORMATTING",
	"php": "PHP backend files (contact.php, api.php, etc.) with PROPER FORMATTING",
	"sql": "MySQL schema with sample data (if database needed)",
	"config": "PHP config file with database connection (if database needed)",
	"readme": "Setup and customization guide for VistaPanel"
	}}

	🖼️ USE THESE REAL IMAGES (randomly selected for this website):
	{images_list}

	IMPORTANT IMAGE USAGE:
	- Use different images for hero, gallery, team, testimonials, blog posts
	- Add proper alt text describing each image
	- Use responsive image techniques (srcset if needed)
	- Images are high-quality 1920x1080, perfect for hero sections

	✨ CODE FORMATTING RULES (CRITICAL):
	1. HTML: Proper indentation with 2 spaces per level
	2. CSS: One rule per line, organized by sections with comments
	3. JavaScript: Proper function formatting with line breaks
	4. PHP: PSR-12 coding standards, proper indentation
	5. NO MINIFIED CODE - Make it readable and maintainable
	6. Add blank lines between major sections
	7. Use \n for newlines in JSON strings
	8. Properly indent nested elements

	🐘 PHP FILE GENERATION (IMPORTANT):
	When generating PHP files, create COMPLETE, FUNCTIONAL code:

	1. contact.php (Contact Form Handler):
	- Validate all inputs (name, email, message)
	- Sanitize data (htmlspecialchars, filter_var)
	- Send email using mail() function
	- Store in database if requested
	- Return JSON response
	- Include CSRF protection
	- Rate limiting (session-based)

	2. config.php (Database Configuration):
	- PDO connection setup
	- Error handling (try-catch)
	- Database credentials (localhost, username, password, dbname)
	- Timezone settings
	- Error reporting settings
	- Session configuration

	3. functions.php (Helper Functions):
	- Database query helpers
	- Input validation functions
	- Sanitization functions
	- Email sending function
	- Authentication helpers (if needed)

	4. api.php (API Endpoints):
	- RESTful API structure
	- JSON responses
	- Error handling
	- Input validation
	- CORS headers (if needed)

	PHP SECURITY REQUIREMENTS:
	- Use prepared statements (PDO) for all database queries
	- Sanitize ALL user inputs
	- Validate email addresses with filter_var()
	- Use password_hash() for passwords
	- Implement CSRF tokens
	- Use htmlspecialchars() for output
	- Set proper error reporting
	- Use sessions securely

	PHP BEST PRACTICES:
	- PSR-12 coding standards
	- Proper error handling (try-catch)
	- Clear variable names
	- Comments for complex logic
	- Separate concerns (config, functions, handlers)
	- Return JSON for AJAX requests
	- Use HTTP status codes

	Example HTML formatting:
	```
	<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n <meta charset=\"UTF-8\">\n <title>Page</title>\n</head>\n<body>\n <header>\n <nav>\n <ul>\n <li><a href=\"#home\">Home</a></li>\n </ul>\n </nav>\n </header>\n</body>\n</html>
	```

	Example PHP formatting:
	```
	<?php\nsession_start();\n\nif ($_SERVER['REQUEST_METHOD'] === 'POST') {{\n $name = htmlspecialchars($_POST['name']);\n $email = filter_var($_POST['email'], FILTER_SANITIZE_EMAIL);\n \n if (empty($name) \|\| empty($email)) {{\n echo json_encode(['success' => false, 'error' => 'Required fields missing']);\n exit;\n }}\n \n // Process form\n echo json_encode(['success' => true, 'message' => 'Form submitted']);\n}}\n?>
	```

	📝 CONTENT REQUIREMENTS:
	1. Write REAL, PROFESSIONAL content (not Lorem Ipsum)
	2. Create compelling headlines and descriptions
	3. Write realistic testimonials with names
	4. Generate actual blog post content
	5. Create detailed service/product descriptions
	6. Write engaging About Us content
	7. Include realistic contact information (use placeholders)

	🎨 DESIGN EXCELLENCE:
	- Modern, professional, visually stunning
	- Consistent spacing (8px grid system)
	- Smooth animations (0.3s transitions)
	- Hover effects on interactive elements
	- Mobile-first responsive design
	- Glassmorphism, gradients, shadows
	- Professional color palette
	- Clean typography (2-3 fonts max)

	🔧 TECHNICAL REQUIREMENTS:
	- Semantic HTML5 (header, nav, main, section, article, footer)
	- CSS Grid + Flexbox layouts
	- Vanilla JavaScript (ES6+)
	- Responsive breakpoints: 320px, 768px, 1024px, 1440px
	- Form validation with error messages
	- Smooth scroll behavior
	- Loading animations
	- Interactive elements (accordions, tabs, modals)

	📱 MUST INCLUDE SECTIONS:
	1. Hero section with CTA button
	2. Navigation (sticky on scroll, mobile menu)
	3. About/Services section
	4. Features/Benefits cards
	5. Gallery/Portfolio (if applicable)
	6. Testimonials (if applicable)
	7. Pricing tables (if applicable)
	8. Team members (if applicable)
	9. Blog posts grid (if applicable)
	10. Contact form with validation
	11. Footer with social links
	12. Back-to-top button

	🗄️ DATABASE (if requested):
	- Normalized MySQL schema
	- Proper indexes and foreign keys
	- Sample data (5-10 realistic entries)
	- PHP config with PDO connection
	- CREATE DATABASE statement
	- CREATE TABLE statements
	- INSERT sample data
	- Proper data types (VARCHAR, INT, TEXT, DATETIME)
	- Auto-increment primary keys
	- Timestamps (created_at, updated_at)

	⚡ INTERACTIVE FEATURES:
	- Smooth scroll to sections
	- Fade-in animations on scroll
	- Form validation (real-time)
	- AJAX form submission (with PHP backend)
	- Image lightbox/modal
	- Mobile hamburger menu
	- Loading spinner
	- Success/error messages
	- Accordion/FAQ
	- Tabs for content
	- Carousel/slider (if needed)

	🚀 PERFORMANCE:
	- Optimized CSS (no unused styles)
	- Efficient JavaScript
	- Lazy loading for images
	- Minimal HTTP requests
	- Fast animations

	📊 SEO & ACCESSIBILITY:
	- Proper meta tags (title, description, keywords)
	- Open Graph tags
	- Semantic HTML structure
	- Alt text for all images
	- ARIA labels where needed
	- Keyboard navigation
	- Focus indicators
	- Sufficient color contrast

	📋 VISTAPANEL SETUP INSTRUCTIONS (in README):
	1. Upload files via File Manager
	2. Create MySQL database in VistaPanel
	3. Import SQL file using phpMyAdmin
	4. Update config.php with database credentials
	5. Set file permissions (755 for directories, 644 for files)
	6. Test contact form
	7. Customize content and images

	IMPORTANT JSON RULES:
	- Return ONLY the JSON object
	- NO markdown code blocks
	- NO explanations before or after
	- Escape quotes with backslash
	- Use \n for newlines
	- Ensure valid JSON syntax
	- Do NOT return null values
	- Generate COMPLETE, FUNCTIONAL code for ALL files

	CREATE PROFESSIONAL, PRODUCTION-READY CODE FOR VISTAPANEL! 🚀"""

	# Enhanced user prompt with detailed specifications
	features_text = ', '.join(req.features) if req.features else 'Standard features'
	color_guide = _get_color_scheme_guide(req.color_scheme)

	user_prompt = f"""🎨 PROJECT BRIEF:

	📋 WEBSITE TYPE: {req.business_type.upper()}

	💬 CLIENT DESCRIPTION:
	{req.prompt}

	🎨 DESIGN SPECIFICATIONS:
	- Color Scheme: {req.color_scheme}
	- Style: Modern, professional, visually stunning
	- Layout: Clean, spacious, well-organized
	- Typography: Professional, readable, hierarchical

	✨ REQUIRED FEATURES:
	{features_text}

	🗄️ DATABASE: {'YES - Include full MySQL schema with sample data' if req.include_database else 'NO - Static website only'}

	🎯 SPECIFIC REQUIREMENTS:

	1. HERO SECTION:
	- Eye-catching headline
	- Compelling subheadline
	- Clear call-to-action button
	- Background: gradient or image
	- Smooth scroll-down indicator

	2. NAVIGATION:
	- Sticky header on scroll
	- Smooth scroll to sections
	- Mobile hamburger menu
	- Active section highlighting

	3. CONTENT SECTIONS:
	- About/Services section with icons
	- Features/Benefits with cards
	- Testimonials with star ratings (if requested)
	- Gallery with lightbox (if requested)
	- Pricing tables (if requested)
	- Team members (if requested)
	- Blog posts grid (if requested)
	- FAQ accordion (if applicable)

	4. CONTACT SECTION:
	- Working contact form with validation
	- Email, phone, address display
	- Social media links
	- Google Maps embed (placeholder)

	5. FOOTER:
	- Multi-column layout
	- Quick links
	- Social media icons
	- Copyright notice
	- Back-to-top button

	6. INTERACTIVE ELEMENTS:
	- Smooth scroll animations (fade-in, slide-up)
	- Hover effects on cards and buttons
	- Loading states for forms
	- Success/error messages
	- Image lazy loading
	- Parallax effects (subtle)

	7. FORMS (if applicable):
	- Real-time validation
	- Clear error messages
	- Success confirmation
	- Spam protection (honeypot)
	- Required field indicators

	8. PERFORMANCE:
	- Optimized CSS (no unused styles)
	- Efficient JavaScript (no jQuery)
	- Fast loading animations
	- Minimal HTTP requests

	9. SEO:
	- Proper meta tags (title, description, keywords)
	- Open Graph tags for social sharing
	- Structured data (JSON-LD)
	- Semantic HTML structure
	- Alt text for all images

	10. ACCESSIBILITY:
	- ARIA labels where needed
	- Keyboard navigation support
	- Focus indicators
	- Sufficient color contrast
	- Screen reader friendly

	{f'''11. DATABASE STRUCTURE (if applicable):
	- Users table (id, name, email, password, created_at)
	- Content table (id, title, description, image, created_at)
	- Messages/Contacts table (id, name, email, message, created_at)
	- Categories/Tags (if blog)
	- Proper relationships and indexes
	- Sample data for testing''' if req.include_database else ''}

	🎨 COLOR SCHEME GUIDANCE:
	{color_guide}

	📱 RESPONSIVE BREAKPOINTS:
	- Mobile: 320px - 767px (single column, stacked layout)
	- Tablet: 768px - 1023px (2 columns where appropriate)
	- Desktop: 1024px+ (full layout, max-width 1400px)

	⚡ MUST INCLUDE:
	- Favicon link (placeholder)
	- Google Fonts (1-2 professional fonts)
	- Font Awesome icons (CDN)
	- Smooth scroll behavior
	- Loading animation on page load
	- 404 error handling
	- Print stylesheet basics

	🚫 AVOID:
	- jQuery or heavy frameworks
	- Inline styles (except critical CSS)
	- !important in CSS (unless necessary)
	- Console.log in production code
	- Hardcoded sensitive data
	- Broken links or placeholder text

	📦 DELIVERABLES:
	Return ONLY valid JSON with these exact keys:
	- html: Complete HTML5 document
	- css: Complete stylesheet with comments
	- js: Complete JavaScript with error handling
	- sql: MySQL schema with sample data (if database requested)
	- config: PHP database config (if database requested)
	- readme: Detailed setup and customization guide

	CREATE A WEBSITE THAT WILL IMPRESS AND DELIGHT! 🚀✨"""

	logger.info(f"Prompt sizes - System: {len(system_prompt)}, User: {len(user_prompt)}")

	# Call Groq API
	headers = {
	"Authorization": f"Bearer {api_key}",
	"Content-Type": "application/json"
	}

	payload = {
	"model": model,
	"messages": [
	{"role": "system", "content": system_prompt},
	{"role": "user", "content": user_prompt}
	],
	"temperature": 0.7,
	"max_tokens": 8000,
	"top_p": 0.9
	}

	logger.info("Calling Groq API...")
	response = requests.post(
	"https://api.groq.com/openai/v1/chat/completions",
	headers=headers,
	json=payload,
	timeout=60
	)

	logger.info(f"Groq Response: {response.status_code}")

	if response.status_code != 200:
	logger.error(f"Groq Error: {response.text}")
	raise HTTPException(status_code=response.status_code, detail=response.text)

	result = response.json()
	raw_content = result['choices'][0]['message']['content']
	logger.info(f"Response length: {len(raw_content)} chars")

	# Try to extract JSON from markdown code blocks if present
	if '```json' in raw_content:
	import re
	json_match = re.search(r'```json\s(.+?)\s```', raw_content, re.DOTALL)
	if json_match:
	raw_content = json_match.group(1)
	logger.info("Extracted JSON from markdown block")
	elif '```' in raw_content:
	import re
	json_match = re.search(r'```\s(.+?)\s```', raw_content, re.DOTALL)
	if json_match:
	raw_content = json_match.group(1)
	logger.info("Extracted content from code block")

	logger.info(f"Preview: {raw_content[:200]}...")

	try:
	generated_content = json.loads(raw_content)

	# Validate that we have the expected structure
	if not isinstance(generated_content, dict):
	raise ValueError("Response is not a JSON object")

	# Check if we have the required files
	required_keys = ['html', 'css', 'js']
	has_required = any(key in generated_content for key in required_keys)

	if not has_required:
	# Check if the response is double-encoded (JSON string containing JSON)
	if len(generated_content) == 1:
	first_key = list(generated_content.keys())[0]
	first_value = generated_content[first_key]
	if isinstance(first_value, str) and first_value.strip().startswith('{'):
	try:
	inner_json = json.loads(first_value)
	if isinstance(inner_json, dict) and any(k in inner_json for k in required_keys):
	generated_content = inner_json
	logger.info("Unwrapped double-encoded JSON")
	except:
	pass

	# Final validation
	if 'html' not in generated_content:
	logger.warning("No HTML in response, using fallback")
	raise ValueError("Missing HTML content")

	logger.info(f"Files: {list(generated_content.keys())}")

	except (json.JSONDecodeError, ValueError) as je:
	logger.error(f"JSON parse failed: {str(je)}")

	# Try to fix common JSON issues
	try:
	# Remove markdown code blocks if still present
	if '```' in raw_content:
	parts = raw_content.split('```')
	for part in parts:
	if '{' in part and '}' in part:
	raw_content = part.replace('json\n', '').replace('json', '').strip()
	break

	# Try parsing again
	generated_content = json.loads(raw_content)

	# Validate again
	if not isinstance(generated_content, dict) or 'html' not in generated_content:
	raise ValueError("Invalid structure after cleanup")

	logger.info("Fixed JSON after cleanup")
	logger.info(f"Files: {list(generated_content.keys())}")

	except Exception as cleanup_error:
	# Final fallback: create minimal structure only if we have HTML-like content
	logger.warning(f"Using fallback structure: {str(cleanup_error)}")

	if '<html' in raw_content.lower() or '<!doctype' in raw_content.lower():
	# Extract HTML if present
	generated_content = {
	"html": raw_content,
	"css": "/* Generated by IONA AI */\nbody { font-family: Arial, sans-serif; margin: 0; padding: 20px; }",
	"js": "// Generated by IONA AI\nconsole.log('Website loaded');",
	"readme": "# Generated Website\n\nThis website was generated by IONA AI.\n\nNote: AI response had formatting issues, minimal CSS/JS provided."
	}
	else:
	# Cannot recover - throw error
	raise HTTPException(
	status_code=500,
	detail=f"AI returned invalid response format. Please try again. Error: {str(je)}"
	)

	logger.info("=== Generation Complete ===")

	return {
	"success": True,
	"model_used": model,
	"files": generated_content,
	"tokens_used": result.get('usage', {}),
	"generation_time": result.get('created', time.time())
	}

	except json.JSONDecodeError as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"JSON Error: {str(e)}")
	raise HTTPException(
	status_code=500,
	detail=f"AI response parsing failed: {str(e)}. The AI may be overloaded, please try again."
	)

	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Error: {str(e)}")
	logger.exception("Traceback:")
	raise HTTPException(status_code=500, detail=f"AI Error: {str(e)}")

	def _get_color_scheme_guide(color_scheme: str) -> str:
	"""Return detailed color guidance based on selected scheme"""
	schemes = {
	"modern": """Primary: #6366f1 (Indigo), Secondary: #8b5cf6 (Purple)
	Accent: #ec4899 (Pink), Background: #0f172a (Dark Blue)
	Text: #f1f5f9 (Light Gray), Use gradients and glassmorphism""",
	"dark": """Primary: #3b82f6 (Blue), Secondary: #10b981 (Green)
	Accent: #f59e0b (Amber), Background: #111827 (Very Dark)
	Text: #f9fafb (White), High contrast, neon accents""",
	"light": """Primary: #2563eb (Blue), Secondary: #7c3aed (Purple)
	Accent: #dc2626 (Red), Background: #ffffff (White)
	Text: #1f2937 (Dark Gray), Clean, minimal, lots of whitespace""",
	"vibrant": """Primary: #f43f5e (Rose), Secondary: #8b5cf6 (Purple)
	Accent: #f59e0b (Amber), Background: #1e293b (Dark Slate)
	Text: #f1f5f9 (Light), Bold colors, high energy""",
	"professional": """Primary: #1e40af (Navy), Secondary: #475569 (Slate)
	Accent: #0891b2 (Cyan), Background: #f8fafc (Off White)
	Text: #0f172a (Dark), Corporate, trustworthy""",
	"warm": """Primary: #ea580c (Orange), Secondary: #dc2626 (Red)
	Accent: #facc15 (Yellow), Background: #292524 (Warm Dark)
	Text: #fafaf9 (Warm White), Cozy, inviting""",
	"nature": """Primary: #16a34a (Green), Secondary: #65a30d (Lime)
	Accent: #0891b2 (Teal), Background: #1c1917 (Earth Dark)
	Text: #fafaf9 (Natural White), Organic, earthy"""
	}
	return schemes.get(color_scheme, schemes["modern"])

	@app.post("/create")
	def create_account(req: AccountRequest):
	"""Create MOFH hosting account"""
	REQUEST_COUNT["total"] += 1
	REQUEST_COUNT["create"] += 1

	try:
	# Use HTTP Basic Authentication (the correct method)
	auth_string = f"{MOFH_API_USERNAME}:{MOFH_API_PASSWORD}"
	auth_b64 = base64.b64encode(auth_string.encode('utf-8')).decode('utf-8')

	headers = {
	'Authorization': f'Basic {auth_b64}',
	'Content-Type': 'application/x-www-form-urlencoded'
	}

	# Data WITHOUT api_user/api_key (they're in the header)
	api_data = {
	'username': req.username,
	'password': req.password,
	'contactemail': req.email,
	'domain': req.domain,
	'plan': req.plan
	}

	response = requests.post(
	f"{MOFH_API_URL}createacct.php",
	data=api_data,
	headers=headers,
	timeout=30,
	verify=False
	)

	return {
	'success': response.status_code == 200,
	'http_code': response.status_code,
	'response': response.text,
	'debug': {
	'api_url': f"{MOFH_API_URL}createacct.php",
	'auth_method': 'Basic Auth (HTTP Header)',
	'api_user_length': len(MOFH_API_USERNAME),
	'api_key_length': len(MOFH_API_PASSWORD),
	'sent_params': list(api_data.keys())
	}
	}

	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	raise HTTPException(status_code=500, detail=str(e))

	class FTPDeployRequest(BaseModel):
	ftp_host: str
	ftp_user: str
	ftp_pass: str
	files: dict # {"index.html": "content", "style.css": "content", ...}

	@validator('ftp_host')
	def validate_host(cls, v):
	if not v or len(v) < 3:
	raise ValueError('Invalid FTP host')
	return v.strip()

	@app.post("/deploy-ftp")
	def deploy_via_ftp(req: FTPDeployRequest):
	"""Deploy files to FTP server (HF Space has no firewall restrictions)"""
	REQUEST_COUNT["total"] += 1

	try:
	import ftplib
	from io import BytesIO

	logger.info(f"[FTP-DEPLOY] Connecting to {req.ftp_host}")

	deployed_files = []
	errors = []

	# Try regular FTP first
	ftp = None
	try:
	ftp = ftplib.FTP(timeout=30)
	ftp.connect(req.ftp_host, 21)
	ftp.login(req.ftp_user, req.ftp_pass)
	logger.info("[FTP-DEPLOY] Connected via regular FTP")
	except Exception as e:
	logger.warning(f"[FTP-DEPLOY] Regular FTP failed: {e}")
	# Try FTP_TLS
	try:
	ftp = ftplib.FTP_TLS(timeout=30)
	ftp.connect(req.ftp_host, 21)
	ftp.login(req.ftp_user, req.ftp_pass)
	ftp.prot_p() # Enable encryption
	logger.info("[FTP-DEPLOY] Connected via FTP_TLS")
	except Exception as e2:
	logger.error(f"[FTP-DEPLOY] FTP_TLS also failed: {e2}")
	raise HTTPException(status_code=500, detail=f"FTP connection failed: {str(e2)}")

	# Set passive mode
	ftp.set_pasv(True)

	# Try to change to web directory
	web_dirs = ['htdocs', 'public_html', 'www', 'html']
	current_dir = '/'

	for web_dir in web_dirs:
	try:
	ftp.cwd(web_dir)
	current_dir = ftp.pwd()
	logger.info(f"[FTP-DEPLOY] Changed to directory: {current_dir}")
	break
	except:
	continue

	logger.info(f"[FTP-DEPLOY] Working directory: {current_dir}")

	# Upload each file
	for filename, content in req.files.items():
	try:
	logger.info(f"[FTP-DEPLOY] Uploading {filename} ({len(content)} bytes)")

	# Convert string to bytes
	file_bytes = BytesIO(content.encode('utf-8'))

	# Upload file
	ftp.storbinary(f'STOR {filename}', file_bytes)

	deployed_files.append(filename)
	logger.info(f"[FTP-DEPLOY] ✓ {filename} uploaded")

	except Exception as e:
	error_msg = f"{filename}: {str(e)}"
	errors.append(error_msg)
	logger.error(f"[FTP-DEPLOY] ✗ {error_msg}")

	# Close FTP connection
	try:
	ftp.quit()
	except:
	ftp.close()

	logger.info(f"[FTP-DEPLOY] Deployment complete. Success: {len(deployed_files)}, Errors: {len(errors)}")

	if not deployed_files:
	raise HTTPException(status_code=500, detail=f"No files deployed. Errors: {', '.join(errors)}")

	return {
	"success": True,
	"deployed_files": deployed_files,
	"errors": errors,
	"message": f"Successfully deployed {len(deployed_files)} file(s)"
	}

	except HTTPException:
	raise
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"[FTP-DEPLOY] Error: {str(e)}")
	raise HTTPException(status_code=500, detail=f"Deployment failed: {str(e)}")


	class GenerateAndDeployRequest(BaseModel):
	prompt: str
	business_type: Optional[str] = "general"
	color_scheme: Optional[str] = "modern"
	include_database: Optional[bool] = False
	features: Optional[List[str]] = []
	ftp_host: str
	ftp_user: str
	ftp_pass: str

	@validator('prompt')
	def validate_prompt(cls, v):
	if not v or len(v.strip()) < 10:
	raise ValueError('Prompt must be at least 10 characters')
	if len(v) > 10000:
	raise ValueError('Prompt too long (max 10000 characters)')
	return v.strip()

	@app.post("/generate-and-deploy")
	def generate_and_deploy(req: GenerateAndDeployRequest):
	"""Generate website with AI and deploy to FTP in one call"""
	REQUEST_COUNT["total"] += 1
	REQUEST_COUNT["generate"] += 1

	logs = []

	try:
	import ftplib
	from io import BytesIO

	logs.append({"time": time.time(), "type": "info", "message": "Starting AI generation..."})

	logger.info("=== IONA AI Generation + Deployment Started ===")
	logger.info(f"Prompt: {req.prompt[:100]}...")
	logger.info(f"FTP Host: {req.ftp_host}, User: {req.ftp_user}")

	api_key = get_next_api_key()
	model = get_random_model()

	logs.append({"time": time.time(), "type": "info", "message": f"Using model: {model}"})

	# Generate with AI - FORCE JSON MODE WITH DETAILED INSTRUCTIONS
	system_prompt = """You are a web development code generator.

	Generate a complete, functional website with HTML, CSS, and JavaScript.

	Return a JSON object with these keys:
	- html: A complete HTML5 document with proper structure
	- css: Complete CSS stylesheet with modern styling
	- js: JavaScript code for interactivity
	- readme: Brief setup instructions

	The website must be:
	- Fully functional and complete
	- Mobile responsive
	- Modern and professional
	- Include all requested features

	IMPORTANT CODE FORMATTING RULES:
	- Use proper indentation (2 spaces per level)
	- Add newlines between sections
	- Format code readably with line breaks
	- Do NOT put everything on one line
	- Use \n for newlines in JSON strings
	- Properly indent nested elements

	IMPORTANT: Do NOT return null values. Generate actual code for each field."""

	user_prompt = f"""Generate a {req.business_type} website with this description:

	{req.prompt}

	Use {req.color_scheme} color scheme and include {', '.join(req.features) if req.features else 'standard'} features.

	Return as JSON with html, css, js, and readme keys."""

	headers = {
	"Authorization": f"Bearer {api_key}",
	"Content-Type": "application/json"
	}

	payload = {
	"model": model,
	"messages": [
	{"role": "system", "content": system_prompt},
	{"role": "user", "content": user_prompt}
	],
	"temperature": 0.7, # Balanced for creativity and consistency
	"max_tokens": 32000, # Maximum tokens for complete generation
	"response_format": {"type": "json_object"} # Force JSON mode
	}

	logs.append({"time": time.time(), "type": "info", "message": "Calling Groq AI..."})

	response = requests.post(
	"https://api.groq.com/openai/v1/chat/completions",
	headers=headers,
	json=payload,
	timeout=180 # 3 minutes for complex generation
	)

	if response.status_code != 200:
	logs.append({"time": time.time(), "type": "error", "message": f"Groq API error: HTTP {response.status_code}"})
	raise HTTPException(status_code=response.status_code, detail=response.text)

	result = response.json()
	raw_content = result['choices'][0]['message']['content']

	logger.info(f"[GENERATE-DEPLOY] Raw response length: {len(raw_content)}")
	logger.info(f"[GENERATE-DEPLOY] Raw response preview: {raw_content[:200]}")

	logs.append({"time": time.time(), "type": "success", "message": "AI generation complete"})
	logs.append({"time": time.time(), "type": "info", "message": "Parsing AI response..."})

	# Parse JSON with better error handling
	generated_content = None

	# Try extracting from markdown code blocks
	if '```json' in raw_content:
	import re
	json_match = re.search(r'```json\s(.+?)\s```', raw_content, re.DOTALL)
	if json_match:
	raw_content = json_match.group(1)
	logger.info("[GENERATE-DEPLOY] Extracted from ```json block")
	elif '```' in raw_content:
	import re
	json_match = re.search(r'```\s(.+?)\s```', raw_content, re.DOTALL)
	if json_match:
	raw_content = json_match.group(1)
	logger.info("[GENERATE-DEPLOY] Extracted from ``` block")

	# Try parsing JSON
	try:
	generated_content = json.loads(raw_content)
	logger.info(f"[GENERATE-DEPLOY] Parsed JSON successfully, keys: {list(generated_content.keys())}")
	except json.JSONDecodeError as e:
	logger.error(f"[GENERATE-DEPLOY] JSON parse failed: {e}")
	logger.error(f"[GENERATE-DEPLOY] Content: {raw_content[:500]}")

	# Try to find JSON object in the response
	import re
	json_pattern = r'\{[^{}](?:\{[^{}]\}[^{}])\}'
	matches = re.findall(json_pattern, raw_content, re.DOTALL)

	for match in matches:
	try:
	generated_content = json.loads(match)
	if 'html' in generated_content:
	logger.info("[GENERATE-DEPLOY] Found valid JSON in response")
	break
	except:
	continue

	if not generated_content:
	logs.append({"time": time.time(), "type": "error", "message": "AI returned invalid JSON format"})
	raise ValueError(f"AI response is not valid JSON. Error: {str(e)}. Response preview: {raw_content[:200]}")

	if 'html' not in generated_content:
	logs.append({"time": time.time(), "type": "error", "message": "No HTML in AI response"})
	raise ValueError("No HTML in AI response")

	# Check if HTML is null or empty
	html_content = generated_content.get('html', '')
	if not html_content or html_content == 'null' or len(html_content.strip()) < 100:
	logs.append({"time": time.time(), "type": "error", "message": f"AI returned invalid HTML (length: {len(html_content)})"})
	logs.append({"time": time.time(), "type": "error", "message": f"Model used: {model}"})
	logs.append({"time": time.time(), "type": "error", "message": f"Response preview: {str(generated_content)[:200]}"})
	raise ValueError(f"AI returned null or empty HTML content. Model: {model}. Please try again.")

	logs.append({"time": time.time(), "type": "success", "message": "AI response parsed successfully"})
	logs.append({"time": time.time(), "type": "info", "message": f"Generated {len(generated_content.get('html', ''))} chars of HTML"})

	logs.append({"time": time.time(), "type": "info", "message": "FTP blocked - returning files to PHP for deployment"})

	# HF Space cannot connect to FTP (port 21 blocked)
	# Return generated files to PHP for deployment
	logger.info("[GENERATE-DEPLOY] FTP blocked by HF network - returning files")

	return {
	"success": True,
	"model_used": model,
	"deployed_files": [],
	"files": {
	'html': generated_content.get('html', ''),
	'css': generated_content.get('css', ''),
	'js': generated_content.get('js', ''),
	'php': generated_content.get('php', ''),
	'sql': generated_content.get('sql', ''),
	'config': generated_content.get('config', ''),
	'readme': generated_content.get('readme', '')
	},
	"ftp_blocked": True,
	"logs": logs,
	"message": "Website generated successfully. FTP blocked - files returned for PHP deployment."
	}

	except HTTPException:
	raise
	except json.JSONDecodeError as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"[GENERATE-DEPLOY] JSON Error: {str(e)}")
	logs.append({"time": time.time(), "type": "error", "message": f"JSON parsing failed: {str(e)}"})
	raise HTTPException(status_code=500, detail=f"AI returned invalid JSON format. Please try again. Error: {str(e)}")
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"[GENERATE-DEPLOY] Error: {str(e)}")
	logs.append({"time": time.time(), "type": "error", "message": str(e)})
	raise HTTPException(status_code=500, detail=f"Generation/Deployment failed: {str(e)}")


	# ============================================================================
	# GITHUB DEPLOYMENT ENDPOINTS
	# ============================================================================

	# Import GitHub deployment module
	github_deploy = None
	try:
	from github_deploy import GitHubDeployment

	# Initialize GitHub Deployment (will be configured via environment variables)
	GITHUB_APP_ID = os.getenv('GITHUB_APP_ID', '')
	GITHUB_CLIENT_ID = os.getenv('GITHUB_CLIENT_ID', '')
	GITHUB_CLIENT_SECRET = os.getenv('GITHUB_CLIENT_SECRET', '')
	GITHUB_PRIVATE_KEY = os.getenv('GITHUB_PRIVATE_KEY', '').replace('\\n', '\n')

	if GITHUB_APP_ID and GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET and GITHUB_PRIVATE_KEY:
	try:
	github_deploy = GitHubDeployment(
	GITHUB_APP_ID,
	GITHUB_CLIENT_ID,
	GITHUB_CLIENT_SECRET,
	GITHUB_PRIVATE_KEY
	)
	logger.info("✅ GitHub Deployment initialized successfully")
	except Exception as e:
	logger.error(f"❌ GitHub Deployment initialization failed: {e}")
	else:
	logger.info("ℹ️ GitHub Deployment not configured (environment variables not set)")

	except ImportError as e:
	logger.error(f"❌ Failed to import github_deploy module: {e}")
	logger.error("❌ Make sure github_deploy.py is in the same directory as app.py")
	except Exception as e:
	logger.error(f"❌ Error loading GitHub deployment: {e}")


	class GitHubOAuthRequest(BaseModel):
	code: str


	class GitHubInstallationTokenRequest(BaseModel):
	installation_id: str


	class GitHubDeploymentStatusRequest(BaseModel):
	owner: str
	repo: str
	run_id: int
	installation_id: str


	class GitHubRepoRequest(BaseModel):
	access_token: str


	class GitHubSetupDeploymentRequest(BaseModel):
	owner: str
	repo: str
	access_token: str
	ftp_server: str
	ftp_username: str
	ftp_password: str
	branch: Optional[str] = 'main'


	class GitHubWorkflowRunsRequest(BaseModel):
	owner: str
	repo: str
	access_token: str
	limit: Optional[int] = 10


	class GitHubWorkflowLogsRequest(BaseModel):
	owner: str
	repo: str
	run_id: int
	access_token: str


	class GitHubTriggerWorkflowRequest(BaseModel):
	owner: str
	repo: str
	access_token: str
	workflow_file: Optional[str] = 'celestine_deploy.yml'
	branch: Optional[str] = 'main'


	@app.get("/github/status")
	def github_status():
	"""Check if GitHub integration is configured"""
	return {
	"configured": github_deploy is not None,
	"app_id": GITHUB_APP_ID if GITHUB_APP_ID else None,
	"client_id": GITHUB_CLIENT_ID if GITHUB_CLIENT_ID else None,
	"message": "GitHub integration is ready" if github_deploy else "GitHub integration not configured"
	}


	@app.post("/github/oauth/exchange")
	def github_oauth_exchange(req: GitHubOAuthRequest):
	"""Exchange OAuth code for access token AND get installation ID"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	# Get OAuth token
	result = github_deploy.exchange_code_for_token(req.code)
	access_token = result.get('access_token')

	# Get user's GitHub App installations
	headers = {
	'Authorization': f'token {access_token}',
	'Accept': 'application/vnd.github.v3+json'
	}

	logger.info("📦 Fetching user's GitHub App installations...")
	response = requests.get(
	'https://api.github.com/user/installations',
	headers=headers,
	timeout=30
	)

	installation_id = None
	if response.status_code == 200:
	installations = response.json().get('installations', [])
	if installations:
	installation_id = str(installations[0]['id'])
	logger.info(f"✓ Found installation ID: {installation_id}")
	else:
	logger.warning("⚠ No installations found for user")
	else:
	logger.warning(f"⚠ Failed to get installations: {response.status_code}")

	return {
	"success": True,
	"access_token": access_token, # Only for initial repo listing
	"installation_id": installation_id, # Store this! Never expires!
	"token_type": result.get('token_type'),
	"scope": result.get('scope')
	}
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"OAuth exchange failed: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/installation-token")
	def get_installation_token(req: GitHubInstallationTokenRequest):
	"""
	Get fresh installation token (valid for 1 hour)
	This is the KEY to solving token expiration issues!
	"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	logger.info(f"🔐 Generating installation token for installation_id: {req.installation_id}")
	token = github_deploy.get_installation_access_token(req.installation_id)
	logger.info(f"✓ Installation token generated (length: {len(token)})")

	return {
	"success": True,
	"token": token,
	"expires_in": 3600, # 1 hour
	"message": "Fresh installation token generated"
	}
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get installation token: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/deployment-status")
	def get_deployment_status(req: GitHubDeploymentStatusRequest):
	"""
	Get deployment status using installation token (never expires!)
	This replaces the need for stored OAuth tokens
	"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	# Generate fresh installation token
	installation_token = github_deploy.get_installation_access_token(req.installation_id)

	# Get workflow run status
	headers = {
	'Authorization': f'token {installation_token}',
	'Accept': 'application/vnd.github.v3+json'
	}

	response = requests.get(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/actions/runs/{req.run_id}',
	headers=headers,
	timeout=30
	)

	if response.status_code != 200:
	raise HTTPException(status_code=response.status_code, detail=response.text)

	data = response.json()

	return {
	"success": True,
	"status": data.get('status'),
	"conclusion": data.get('conclusion'),
	"created_at": data.get('created_at'),
	"updated_at": data.get('updated_at'),
	"html_url": data.get('html_url')
	}
	except HTTPException:
	raise
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get deployment status: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/repos")
	def github_get_repos(req: GitHubRepoRequest):
	"""Get user's GitHub repositories"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	repos = github_deploy.get_user_repos(req.access_token)
	return {
	"success": True,
	"repositories": repos,
	"count": len(repos)
	}
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get repos: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/detect-project")
	def github_detect_project(req: GitHubSetupDeploymentRequest):
	"""Detect project type and build configuration"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	project_config = github_deploy.detect_project_type(
	req.owner,
	req.repo,
	req.access_token
	)
	return {
	"success": True,
	"project_config": project_config
	}
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Project detection failed: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/setup-deployment")
	def github_setup_deployment(req: GitHubSetupDeploymentRequest):
	"""
	Complete deployment setup:
	1. Detect project type
	2. Create FTP secrets
	3. Inject workflow file
	"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	logger.info("=" * 80)
	logger.info("🚀 GITHUB DEPLOYMENT SETUP STARTED")
	logger.info("=" * 80)
	logger.info(f"📦 Repository: {req.owner}/{req.repo}")
	logger.info(f"🌿 Branch: {req.branch}")
	logger.info(f"🔐 Access Token: {'✓ Present' if req.access_token else '✗ Missing'} (length: {len(req.access_token) if req.access_token else 0})")
	logger.info(f"🌐 FTP Server: {req.ftp_server}")
	logger.info(f"👤 FTP Username: {req.ftp_username if req.ftp_username else '✗ EMPTY'}")
	logger.info(f"🔑 FTP Password: {'✓ Present' if req.ftp_password else '✗ EMPTY'} (length: {len(req.ftp_password) if req.ftp_password else 0})")
	logger.info("-" * 80)

	if not req.ftp_username:
	logger.error("❌ FTP Username is empty!")
	raise HTTPException(status_code=400, detail="FTP Username is required")

	if not req.ftp_password:
	logger.error("❌ FTP Password is empty!")
	raise HTTPException(status_code=400, detail="FTP Password is required")

	result = github_deploy.setup_deployment(
	req.owner,
	req.repo,
	req.access_token,
	req.ftp_server,
	req.ftp_username,
	req.ftp_password,
	req.branch
	)

	if not result['success']:
	logger.error(f"❌ Deployment setup failed: {result.get('error', 'Unknown error')}")
	raise HTTPException(status_code=500, detail=result.get('error', 'Setup failed'))

	logger.info("=" * 80)
	logger.info("✅ GITHUB DEPLOYMENT SETUP COMPLETED SUCCESSFULLY")
	logger.info(f"📦 Project Type: {result.get('project_type')}")
	logger.info(f"🔨 Build Command: {result.get('build_command')}")
	logger.info(f"📂 Output Directory: {result.get('output_dir')}")
	logger.info(f"🔗 Workflow URL: {result.get('workflow_url')}")
	logger.info(f"🎬 Actions URL: {result.get('actions_url')}")
	logger.info("=" * 80)

	return result
	except HTTPException:
	raise
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error("=" * 80)
	logger.error(f"❌ DEPLOYMENT SETUP EXCEPTION: {str(e)}")
	logger.error("=" * 80)
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/workflow-runs")
	def github_workflow_runs(req: GitHubWorkflowRunsRequest):
	"""Get workflow run history"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	runs = github_deploy.get_workflow_runs(
	req.owner,
	req.repo,
	req.access_token,
	req.limit
	)
	return {
	"success": True,
	"runs": runs,
	"count": len(runs)
	}
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get workflow runs: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/workflow-logs")
	def github_workflow_logs(req: GitHubWorkflowLogsRequest):
	"""Get workflow run logs"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	logs = github_deploy.get_workflow_logs(
	req.owner,
	req.repo,
	req.run_id,
	req.access_token
	)
	return {
	"success": True,
	"logs": logs
	}
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get logs: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/trigger-workflow")
	def github_trigger_workflow(req: GitHubTriggerWorkflowRequest):
	"""Manually trigger a workflow"""
	REQUEST_COUNT["total"] += 1

	if not github_deploy:
	raise HTTPException(status_code=503, detail="GitHub integration not configured")

	try:
	success = github_deploy.trigger_workflow(
	req.owner,
	req.repo,
	req.workflow_file,
	req.access_token,
	req.branch
	)

	if not success:
	raise HTTPException(status_code=500, detail="Failed to trigger workflow")

	return {
	"success": True,
	"message": "Workflow triggered successfully"
	}
	except HTTPException:
	raise
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to trigger workflow: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	# ============================================================================
	# GITHUB DEPLOYMENT STATUS TRACKING (WITH CACHING)
	# ============================================================================

	# In-memory cache for deployment status (reduces GitHub API calls)
	deployment_status_cache = {}
	CACHE_TTL = 30 # seconds

	class GitHubDeploymentStatusRequest(BaseModel):
	access_token: str
	owner: str
	repo: str
	branch: str = "main"

	class GitHubLatestCommitRequest(BaseModel):
	access_token: str
	owner: str
	repo: str
	branch: str = "main"

	class GitHubTriggerDeployRequest(BaseModel):
	access_token: str
	owner: str
	repo: str
	branch: str = "main"

	class GitHubCreateDeploymentRequest(BaseModel):
	access_token: str
	owner: str
	repo: str
	ref: str = "main"
	environment: str = "production"
	description: str = "Deploying via CELESTINE"

	class GitHubUpdateDeploymentStatusRequest(BaseModel):
	access_token: str
	owner: str
	repo: str
	deployment_id: int
	state: str # pending, success, failure, error
	environment_url: Optional[str] = ""
	description: Optional[str] = ""


	@app.post("/github/deployment-status")
	def get_deployment_status(req: GitHubDeploymentStatusRequest):
	"""
	Get real-time deployment status from GitHub Actions
	Returns: status, conclusion, commit info, workflow URL
	Caches results for 30 seconds to reduce API calls
	"""
	REQUEST_COUNT["total"] += 1

	try:
	cache_key = f"{req.owner}/{req.repo}/{req.branch}"
	now = time.time()

	# Check cache first
	if cache_key in deployment_status_cache:
	cached_data, cached_time = deployment_status_cache[cache_key]
	if now - cached_time < CACHE_TTL:
	logger.info(f"✓ Cache hit for {cache_key} (age: {int(now - cached_time)}s)")
	cached_data['cached'] = True
	cached_data['cache_age'] = int(now - cached_time)
	return cached_data

	logger.info(f"Fetching deployment status for {req.owner}/{req.repo} (branch: {req.branch})")

	headers = {
	'Authorization': f'token {req.access_token}',
	'Accept': 'application/vnd.github.v3+json',
	'User-Agent': 'CELESTINE-Hosting'
	}

	# Get latest workflow runs for the branch
	response = requests.get(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/actions/runs',
	headers=headers,
	params={
	'branch': req.branch,
	'per_page': 5,
	'status': 'completed,in_progress,queued'
	},
	timeout=15
	)

	if response.status_code != 200:
	logger.error(f"GitHub API error: {response.status_code} - {response.text}")
	raise HTTPException(status_code=response.status_code, detail=f"GitHub API error: {response.text}")

	data = response.json()
	workflow_runs = data.get('workflow_runs', [])

	if not workflow_runs:
	result = {
	'success': True,
	'status': 'unknown',
	'conclusion': None,
	'commit_sha': '',
	'commit_msg': '',
	'workflow_url': '',
	'run_id': None,
	'cached': False,
	'message': 'No workflow runs found'
	}
	deployment_status_cache[cache_key] = (result, now)
	return result

	# Get the most recent run
	latest_run = workflow_runs[0]

	# Map GitHub status to our status
	gh_status = latest_run.get('status', 'unknown')
	gh_conclusion = latest_run.get('conclusion')

	# Determine final status
	if gh_status == 'completed':
	if gh_conclusion == 'success':
	status = 'success'
	elif gh_conclusion in ['failure', 'cancelled', 'timed_out']:
	status = 'failure'
	else:
	status = 'unknown'
	elif gh_status == 'in_progress':
	status = 'in_progress'
	elif gh_status == 'queued':
	status = 'queued'
	else:
	status = 'unknown'

	result = {
	'success': True,
	'status': status,
	'conclusion': gh_conclusion,
	'commit_sha': latest_run.get('head_sha', ''),
	'commit_msg': latest_run.get('head_commit', {}).get('message', ''),
	'workflow_url': latest_run.get('html_url', ''),
	'run_id': latest_run.get('id'),
	'created_at': latest_run.get('created_at'),
	'updated_at': latest_run.get('updated_at'),
	'cached': False,
	'cache_age': 0
	}

	# Cache the result
	deployment_status_cache[cache_key] = (result, now)
	logger.info(f"✓ Cached deployment status for {cache_key}: {status}")

	return result

	except HTTPException:
	raise
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get deployment status: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/latest-commit")
	def get_latest_commit(req: GitHubLatestCommitRequest):
	"""
	Get latest commit on a branch
	Used for auto-deploy detection
	Caches results for 60 seconds
	"""
	REQUEST_COUNT["total"] += 1

	try:
	cache_key = f"commit_{req.owner}/{req.repo}/{req.branch}"
	now = time.time()

	# Check cache (longer TTL for commits)
	if cache_key in deployment_status_cache:
	cached_data, cached_time = deployment_status_cache[cache_key]
	if now - cached_time < 60: # 60 second cache for commits
	logger.info(f"✓ Cache hit for commit {cache_key}")
	cached_data['cached'] = True
	return cached_data

	logger.info(f"Fetching latest commit for {req.owner}/{req.repo} (branch: {req.branch})")

	headers = {
	'Authorization': f'token {req.access_token}',
	'Accept': 'application/vnd.github.v3+json',
	'User-Agent': 'CELESTINE-Hosting'
	}

	# Get latest commit
	response = requests.get(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/commits/{req.branch}',
	headers=headers,
	timeout=15
	)

	if response.status_code != 200:
	logger.error(f"GitHub API error: {response.status_code}")
	raise HTTPException(status_code=response.status_code, detail="Failed to fetch commit")

	commit_data = response.json()

	result = {
	'success': True,
	'sha': commit_data.get('sha', ''),
	'message': commit_data.get('commit', {}).get('message', ''),
	'author': commit_data.get('commit', {}).get('author', {}).get('name', ''),
	'date': commit_data.get('commit', {}).get('author', {}).get('date', ''),
	'cached': False
	}

	# Cache the result
	deployment_status_cache[cache_key] = (result, now)
	logger.info(f"✓ Cached commit info for {cache_key}: {result['sha'][:7]}")

	return result

	except HTTPException:
	raise
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get latest commit: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/trigger-deploy")
	def trigger_deploy(req: GitHubTriggerDeployRequest):
	"""
	Trigger a deployment by dispatching the workflow
	Clears cache to force fresh status check
	"""
	REQUEST_COUNT["total"] += 1

	try:
	logger.info(f"Triggering deployment for {req.owner}/{req.repo} (branch: {req.branch})")

	headers = {
	'Authorization': f'token {req.access_token}',
	'Accept': 'application/vnd.github.v3+json',
	'User-Agent': 'CELESTINE-Hosting',
	'Content-Type': 'application/json'
	}

	# Trigger workflow dispatch
	response = requests.post(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/actions/workflows/deploy.yml/dispatches',
	headers=headers,
	json={'ref': req.branch},
	timeout=15
	)

	# 204 = success (no content)
	if response.status_code == 204:
	# Clear cache to force fresh status check
	cache_key = f"{req.owner}/{req.repo}/{req.branch}"
	if cache_key in deployment_status_cache:
	del deployment_status_cache[cache_key]
	logger.info(f"✓ Cleared cache for {cache_key}")

	logger.info(f"✓ Deployment triggered successfully for {req.owner}/{req.repo}")
	return {
	'success': True,
	'message': 'Deployment triggered successfully'
	}
	else:
	logger.error(f"Failed to trigger deployment: {response.status_code} - {response.text}")
	return {
	'success': False,
	'error': f"GitHub API returned {response.status_code}",
	'details': response.text
	}

	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to trigger deployment: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/create-deployment")
	def create_github_deployment(req: GitHubCreateDeploymentRequest):
	"""
	Create a GitHub deployment (for status tracking on repo page)
	This fixes the yellow dots issue
	"""
	REQUEST_COUNT["total"] += 1

	try:
	logger.info(f"Creating GitHub deployment for {req.owner}/{req.repo}")

	headers = {
	'Authorization': f'token {req.access_token}',
	'Accept': 'application/vnd.github.v3+json',
	'User-Agent': 'CELESTINE-Hosting',
	'Content-Type': 'application/json'
	}

	# Create deployment
	response = requests.post(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/deployments',
	headers=headers,
	json={
	'ref': req.ref,
	'environment': req.environment,
	'description': req.description,
	'auto_merge': False,
	'required_contexts': [],
	'production_environment': True
	},
	timeout=15
	)

	if response.status_code in [200, 201]:
	deployment_data = response.json()
	logger.info(f"✓ GitHub deployment created: {deployment_data.get('id')}")
	return {
	'success': True,
	'deployment_id': deployment_data.get('id'),
	'sha': deployment_data.get('sha')
	}
	else:
	logger.error(f"Failed to create deployment: {response.status_code} - {response.text}")
	return {
	'success': False,
	'error': f"GitHub API returned {response.status_code}",
	'details': response.text
	}

	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to create deployment: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/update-deployment-status")
	def update_github_deployment_status(req: GitHubUpdateDeploymentStatusRequest):
	"""
	Update GitHub deployment status (success/failure)
	This updates the dots on the GitHub repo page
	"""
	REQUEST_COUNT["total"] += 1

	try:
	logger.info(f"Updating deployment status for {req.owner}/{req.repo} (deployment: {req.deployment_id}, state: {req.state})")

	headers = {
	'Authorization': f'token {req.access_token}',
	'Accept': 'application/vnd.github.v3+json',
	'User-Agent': 'CELESTINE-Hosting',
	'Content-Type': 'application/json'
	}

	# Update deployment status
	response = requests.post(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/deployments/{req.deployment_id}/statuses',
	headers=headers,
	json={
	'state': req.state,
	'environment_url': req.environment_url,
	'description': req.description,
	'auto_inactive': False
	},
	timeout=15
	)

	if response.status_code in [200, 201]:
	logger.info(f"✓ Deployment status updated to {req.state}")
	return {
	'success': True,
	'message': f'Deployment status updated to {req.state}'
	}
	else:
	logger.error(f"Failed to update deployment status: {response.status_code} - {response.text}")
	return {
	'success': False,
	'error': f"GitHub API returned {response.status_code}",
	'details': response.text
	}

	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to update deployment status: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	# Cache cleanup task (runs every 5 minutes)
	@app.on_event("startup")
	async def startup_cache_cleanup():
	"""Clean up old cache entries periodically"""
	import asyncio

	async def cleanup_task():
	while True:
	await asyncio.sleep(300) # 5 minutes
	now = time.time()
	expired_keys = []

	for key, (data, cached_time) in deployment_status_cache.items():
	if now - cached_time > 300: # 5 minutes
	expired_keys.append(key)

	for key in expired_keys:
	del deployment_status_cache[key]

	if expired_keys:
	logger.info(f"🧹 Cleaned up {len(expired_keys)} expired cache entries")

	asyncio.create_task(cleanup_task())


	# ============================================================================
	# GITHUB WEBHOOK ENDPOINT (Fixes 404 errors)
	# ============================================================================

	import hmac
	import hashlib

	def verify_github_webhook_signature(payload_body: bytes, secret_token: str, signature_header: str) -> bool:
	"""Verify that the webhook payload was sent from GitHub."""
	if not signature_header:
	return False

	hash_object = hmac.new(secret_token.encode('utf-8'), msg=payload_body, digestmod=hashlib.sha256)
	expected_signature = "sha256=" + hash_object.hexdigest()

	return hmac.compare_digest(expected_signature, signature_header)

	@app.post("/github/webhook")
	async def github_webhook(request: Request):
	"""
	Handle GitHub webhook events
	Used for real-time deployment status updates
	"""
	REQUEST_COUNT["total"] += 1

	try:
	# 1. Verify Webhook Signature
	github_secret = os.getenv('WEBHOOK_SECRET', 'savage')
	signature_header = request.headers.get('X-Hub-Signature-256', '')

	# Read raw body for signature verification
	payload_body = await request.body()

	if not verify_github_webhook_signature(payload_body, github_secret, signature_header):
	logger.warning("Invalid GitHub webhook signature")
	return {"success": False, "error": "Invalid signature"}

	event_type = request.headers.get('X-GitHub-Event', 'unknown')

	# Handle ping and installation events immediately (required for GitHub Apps)
	if event_type == 'ping':
	logger.info("Received ping event from GitHub App")
	return {"success": True, "message": "pong"}

	if event_type == 'installation' or event_type == 'installation_repositories':
	logger.info(f"Received {event_type} event from GitHub App")
	return {"success": True, "message": f"{event_type} event received"}

	payload = await request.json()

	logger.info("=" * 80)
	logger.info("📨 GitHub Webhook Received")
	logger.info("=" * 80)
	logger.info(f"Event Type: {event_type}")

	repo_full_name = "unknown"
	if 'repository' in payload:
	repo_full_name = payload['repository']['full_name']
	logger.info(f"Repository: {repo_full_name}")

	# Clear cache for this repo to force fresh status check
	cache_keys_to_clear = [k for k in deployment_status_cache.keys() if repo_full_name in k]
	for key in cache_keys_to_clear:
	del deployment_status_cache[key]
	logger.info(f"✓ Cleared cache for {key}")

	# Handle workflow_run events
	if event_type == 'workflow_run':
	workflow_run = payload.get('workflow_run', {})
	action = payload.get('action', '')

	repo_owner = payload['repository']['owner']['login']
	repo_name = payload['repository']['name']
	run_id = workflow_run.get('id')
	status = workflow_run.get('status')
	conclusion = workflow_run.get('conclusion')
	html_url = workflow_run.get('html_url')

	logger.info(f"Workflow Run: {action}")
	logger.info(f"Run ID: {run_id}")
	logger.info(f"Status: {status}")
	logger.info(f"Conclusion: {conclusion}")

	# Update database
	if run_id:
	update_deployment_status(
	repo_owner=repo_owner,
	repo_name=repo_name,
	workflow_run_id=run_id,
	status=status,
	conclusion=conclusion,
	workflow_url=html_url
	)

	# Handle deployment_status events
	elif event_type == 'deployment_status':
	deployment = payload.get('deployment', {})
	deployment_status = payload.get('deployment_status', {})

	repo_owner = payload['repository']['owner']['login']
	repo_name = payload['repository']['name']
	state = deployment_status.get('state')

	logger.info(f"Deployment Status: {state}")

	# Map to our status
	status_map = {
	'pending': 'pending',
	'queued': 'queued',
	'in_progress': 'in_progress',
	'success': 'completed',
	'failure': 'failed',
	'error': 'failed'
	}

	mapped_status = status_map.get(state, 'pending')
	# This could fall back to other updates if needed

	return {
	"success": True,
	"message": "Webhook processed",
	"event": event_type,
	"repo": repo_full_name
	}

	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Webhook processing error: {e}")
	return {
	"success": False,
	"error": str(e)
	}


	# ============================================================================
	# GITHUB ACTIONS LOGS ENDPOINT (Real-time workflow logs)
	# ============================================================================

	class GitHubWorkflowLogsRequest(BaseModel):
	access_token: str
	owner: str
	repo: str
	run_id: Optional[int] = None
	branch: str = "main"

	@app.post("/github/workflow-logs")
	def get_workflow_logs(req: GitHubWorkflowLogsRequest):
	"""
	Get real-time GitHub Actions workflow logs
	Returns actual logs from the running/completed workflow
	"""
	REQUEST_COUNT["total"] += 1

	try:
	logger.info(f"Fetching workflow logs for {req.owner}/{req.repo}")

	headers = {
	'Authorization': f'token {req.access_token}',
	'Accept': 'application/vnd.github.v3+json',
	'User-Agent': 'CELESTINE-Hosting'
	}

	# If run_id not provided, get the latest run
	if not req.run_id:
	response = requests.get(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/actions/runs',
	headers=headers,
	params={'branch': req.branch, 'per_page': 1},
	timeout=15
	)

	if response.status_code != 200:
	raise HTTPException(status_code=response.status_code, detail="Failed to fetch runs")

	runs = response.json().get('workflow_runs', [])
	if not runs:
	return {
	'success': True,
	'logs': [],
	'jobs': [],
	'message': 'No workflow runs found'
	}

	req.run_id = runs[0]['id']

	# Get jobs for this run
	jobs_response = requests.get(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/actions/runs/{req.run_id}/jobs',
	headers=headers,
	timeout=15
	)

	if jobs_response.status_code != 200:
	raise HTTPException(status_code=jobs_response.status_code, detail="Failed to fetch jobs")

	jobs_data = jobs_response.json()
	jobs = jobs_data.get('jobs', [])

	# Extract steps from all jobs
	all_steps = []
	for job in jobs:
	job_name = job.get('name', 'Unknown Job')
	steps = job.get('steps', [])

	for step in steps:
	step_name = step.get('name', 'Unknown Step')
	status = step.get('status', 'pending')
	conclusion = step.get('conclusion')
	started_at = step.get('started_at', '')
	completed_at = step.get('completed_at', '')

	# Map status to our format
	if status == 'completed':
	if conclusion == 'success':
	step_status = 'completed'
	else:
	step_status = 'failed'
	elif status == 'in_progress':
	step_status = 'in-progress'
	else:
	step_status = 'pending'

	all_steps.append({
	'job': job_name,
	'name': step_name,
	'status': step_status,
	'conclusion': conclusion,
	'started_at': started_at,
	'completed_at': completed_at,
	'number': step.get('number', 0)
	})

	# Try to get logs (may not be available for in-progress runs)
	logs_text = []
	try:
	logs_response = requests.get(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/actions/runs/{req.run_id}/logs',
	headers=headers,
	timeout=15,
	allow_redirects=True
	)

	if logs_response.status_code == 200:
	# Parse logs (they come as a zip file, but we'll get the text)
	logs_text = logs_response.text.split('\n')[:100] # First 100 lines
	except:
	pass

	return {
	'success': True,
	'run_id': req.run_id,
	'jobs': jobs,
	'steps': all_steps,
	'logs': logs_text,
	'total_steps': len(all_steps)
	}

	except HTTPException:
	raise
	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get workflow logs: {e}")
	raise HTTPException(status_code=500, detail=str(e))


	@app.post("/github/workflow-steps")
	def get_workflow_steps(req: GitHubWorkflowLogsRequest):
	"""
	Get workflow steps with real-time status
	Optimized for deployment viewer UI
	"""
	REQUEST_COUNT["total"] += 1

	try:
	logger.info(f"Fetching workflow steps for {req.owner}/{req.repo}")

	headers = {
	'Authorization': f'token {req.access_token}',
	'Accept': 'application/vnd.github.v3+json',
	'User-Agent': 'CELESTINE-Hosting'
	}

	# Get latest run if run_id not provided
	if not req.run_id:
	response = requests.get(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/actions/runs',
	headers=headers,
	params={'branch': req.branch, 'per_page': 1},
	timeout=15
	)

	if response.status_code != 200:
	return {'success': False, 'error': 'Failed to fetch runs'}

	runs = response.json().get('workflow_runs', [])
	if not runs:
	return {'success': True, 'steps': [], 'logs': []}

	req.run_id = runs[0]['id']

	# Get jobs
	jobs_response = requests.get(
	f'https://api.github.com/repos/{req.owner}/{req.repo}/actions/runs/{req.run_id}/jobs',
	headers=headers,
	timeout=15
	)

	if jobs_response.status_code != 200:
	return {'success': False, 'error': 'Failed to fetch jobs'}

	jobs = jobs_response.json().get('jobs', [])

	# Build simplified steps list for UI
	steps = []
	logs = []

	for job in jobs:
	for step in job.get('steps', []):
	step_name = step.get('name', '')
	status = step.get('status', 'pending')
	conclusion = step.get('conclusion')

	# Map to UI status
	if status == 'completed':
	ui_status = 'completed' if conclusion == 'success' else 'failed'
	elif status == 'in_progress':
	ui_status = 'in-progress'
	else:
	ui_status = 'pending'

	steps.append({
	'id': step.get('number', len(steps) + 1),
	'title': step_name,
	'status': ui_status
	})

	# Add log entry
	if status != 'pending':
	timestamp = step.get('started_at', '')
	if timestamp:
	time_str = timestamp.split('T')[1][:8] if 'T' in timestamp else ''

	if ui_status == 'completed':
	logs.append({
	'time': time_str,
	'text': f"✓ {step_name}",
	'color': 'text-emerald-400'
	})
	elif ui_status == 'failed':
	logs.append({
	'time': time_str,
	'text': f"✗ {step_name} failed",
	'color': 'text-red-400'
	})
	elif ui_status == 'in-progress':
	logs.append({
	'time': time_str,
	'text': f"⟳ {step_name}...",
	'color': 'text-indigo-400'
	})

	return {
	'success': True,
	'run_id': req.run_id,
	'steps': steps,
	'logs': logs
	}

	except Exception as e:
	REQUEST_COUNT["errors"] += 1
	logger.error(f"Failed to get workflow steps: {e}")
	return {
	'success': False,
	'error': str(e),
	'steps': [],
	'logs': []
	}