updates

.env

@@ -1,10 +0,0 @@
-# OpenAI API Key
-#OPENAI_API_KEY="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"
-OPENAI_API_KEY="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"
-# Google API Key (for Gemini)
-GOOGLE_API_KEY="AIzaSyCH4rdbuK1cfRpwkhpnpxbdWnrO8RsxAD8"
-MESHY_API_KEY="msy_UnUQpybrhKHfDdgIbpkYw4BEBWZ2WV2wEImI"
-SUPABASE_URL="https://blhjlpokxsdalllewjbx.supabase.co"
-SUPABASE_KEY="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImJsaGpscG9reHNkYWxsbGV3amJ4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDgyNjY0MjksImV4cCI6MjA2Mzg0MjQyOX0.TsoeN7Lid7gmlTJ18Ayp31LEt6Xpyg5VbKt4J5EJGNE"
-STRIPE_SECRET_KEY=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
-#STRIPE_WEBHOOK_SECRET=

README.md

@@ -1,220 +1,84 @@
 ---
-title: 3D E-Commerce Backend API
+title: 3DAI API Backend
 emoji: 🎯
 colorFrom: blue
 colorTo: purple
 sdk: docker
-sdk_version: "4.36.0"
-app_file: main.py
 app_port: 7860
 pinned: false
+license: apache-2.0
 ---
 
-# 3D E-Commerce Backend API
+# 3DAI API Backend
 
-This repository contains a FastAPI backend for a robust 3D model e-commerce platform. It integrates:
+A FastAPI backend for 3D AI model generation services.
 
-- **Supabase** for authentication, user, and credit management
-- **Meshy** for 3D model generation (Image-to-3D, Text-to-3D)
-- **OpenAI** for prompt reframing
-- Endpoints for user onboarding, credit-guarded model generation, credit purchase, order placement, and user dashboard
+## Features
 
----
-
-## Table of Contents
-
-- [Prerequisites](#prerequisites)
-- [Installation](#installation)
-- [Configuration](#configuration)
-- [Running Locally](#running-locally)
-- [API Endpoints](#api-endpoints)
-  - [Authentication](#authentication)
-  - [User Onboarding & Profile](#user-onboarding--profile)
-  - [Credits](#credits)
-  - [3D Model Generation](#3d-model-generation)
-  - [Orders](#orders)
-  - [User Dashboard](#user-dashboard)
-  - [Health Check](#health-check)
-- [References](#references)
-
----
+- User authentication with Supabase
+- Image-to-3D conversion using Meshy AI
+- Text-to-3D conversion
+- Credit system for usage tracking
+- Stripe integration for payments
 
-## Prerequisites
-
-- Python 3.10+
-- `pip`
-- Supabase project (with tables: User, User_Credit_Account, Generated_Models, Model_Order_History, Credit_Order_History)
-- Meshy and OpenAI API keys
-
----
+## Environment Variables
 
-## Installation
+Create a `.env` file with the following variables:
 
-```bash
-git clone <your-repo-url>
-cd api-backend
-python -m venv venv
-source venv/bin/activate
-pip install -r requirements.txt
 ```
-
----
-
-## Configuration
-
-Create a `.env` file in the project root:
-
-```ini
 SUPABASE_URL=https://<your-supabase>.supabase.co
 SUPABASE_KEY=<your-supabase-service-role-key>
-MESHY_API_KEY=msy_<your_meshy_key>
-OPENAI_API_KEY=sk-<your_openai_key>
+JWT_SECRET_KEY=<your-jwt-secret-key>
+OPENAI_API_KEY=<your-openai-api-key>
+STRIPE_SECRET_KEY=<your-stripe-secret-key>
 ```
 
----
-
-## Running Locally
+## Local Development
 
+1. Install dependencies:
 ```bash
-export SUPABASE_URL=...
-export SUPABASE_KEY=...
-export MESHY_API_KEY=...
-export OPENAI_API_KEY=...
-python main.py
+pip install -r requirements.txt
 ```
 
-- Swagger UI: http://127.0.0.1:8000/docs
-
----
-
-## API Endpoints
-
-### Authentication
-
-- **POST `/auth/signup`**  
-  Sign up a new user.  
-  **Body:** `{ "email": "...", "password": "..." }`
-
-- **POST `/auth/signin`**  
-  Sign in and receive JWT.  
-  **Body:** `{ "email": "...", "password": "..." }`  
-  **Response:** `{ "access_token": "...", "user": {...} }`
-
-- **POST `/auth/complete-profile`**  
-  Complete user profile and initialize credits.  
-  **Auth:** Bearer token  
-  **Body:** `{ "address": "...", "fullname": "...", "phone_number": "..." }`
-
----
-
-### User Onboarding & Profile
-
-- **GET `/user/profile`**  
-  Get current user's profile.  
-  **Auth:** Bearer token
-
----
-
-### Credits
-
-- **GET `/user/credits`**  
-  Get available generation credits.  
-  **Auth:** Bearer token
-
-- **POST `/credits/purchase`**  
-  Purchase credits, updates credit account and order history.  
-  **Auth:** Bearer token  
-  **Body:**  
-  ```json
-  {
-    "number_of_generations": 10,
-    "price": 19.99,
-    "transaction_id": "txn_123"
-  }
-  ```
-
----
-
-### 3D Model Generation
-
-- **POST `/req-img-to-3d`**  
-  Generate 3D model from image (costs 1 credit).  
-  **Auth:** Bearer token  
-  **Body:** `multipart/form-data` with `image` file
-
-- **GET `/req-result-img-to-3d/{task_id}`**  
-  Get status/result of image-to-3D task.  
-  **Auth:** Bearer token
-
-- **GET `/list-img-to-3d-req`**  
-  List all image-to-3D tasks for user.  
-  **Auth:** Bearer token
-
-- **POST `/req-text-to-3d`**  
-  Generate 3D model from text (costs 1 credit, prompt reframed by OpenAI).  
-  **Auth:** Bearer token  
-  **Body:** `{ "text": "..." }`
+2. Run the development server:
+```bash
+uvicorn main:app --host 0.0.0.0 --port 7860 --reload
+```
 
-- **GET `/req-result-text-to-3d/{task_id}`**  
-  Get status/result of text-to-3D task.  
-  **Auth:** Bearer token
+3. Visit http://localhost:7860/docs for API documentation
 
-- **GET `/list-text-to-3d-req`**  
-  List all text-to-3D tasks for user.  
-  **Auth:** Bearer token
+## Deployment
 
----
+### Hugging Face Spaces
 
-### Orders
-
-- **POST `/orders/place`**  
-  Place an order for a 3D model print.  
-  **Auth:** Bearer token  
-  **Body:**  
-  ```json
-  {
-    "generated_model_id": "...",
-    "price": 29.99,
-    "packaging_price": 5.00,
-    "material_price": 10.00,
-    "delivery_address": "...",
-    "order_status": "pending",
-    "estimated_delivery_date": "2024-07-01",
-    "shipping_tracking_id": "track_123",
-    "payment_status": "paid",
-    "transaction_id": "txn_456"
-  }
-  ```
-
-- **GET `/user/orders`**  
-  Get all orders for the current user.  
-  **Auth:** Bearer token
+This app is configured to run on Hugging Face Spaces using Docker. Make sure to:
 
----
+1. Set all required environment variables in your Space settings
+2. Use the Docker SDK configuration
+3. Set app_port to 7860
 
-### User Dashboard
+### Environment Setup for Deployment
 
-- **GET `/user/models`**  
-  Get all generated models for the current user.  
-  **Auth:** Bearer token
+Set these environment variables in your deployment platform:
 
----
+- `SUPABASE_URL`: Your Supabase project URL
+- `SUPABASE_KEY`: Your Supabase service role key
+- `JWT_SECRET_KEY`: A secure random string for JWT signing
+- `OPENAI_API_KEY`: Your OpenAI API key
+- `STRIPE_SECRET_KEY`: Your Stripe secret key
 
-### Health Check
+## API Documentation
 
-- **GET `/`**  
-  Returns `{ "status": "ok" }`
+Once running, visit `/docs` for interactive API documentation.
 
----
+## Testing
 
-## References
+Run the comprehensive test suite:
 
-- [Supabase Docs](https://supabase.com/docs)
-- [Meshy Image-to-3D API](https://docs.meshy.ai/en/api/image-to-3d)
-- [Meshy Text-to-3D API](https://docs.meshy.ai/en/api/text-to-3d)
-- [OpenAI Chat API](https://platform.openai.com/docs/api-reference/chat/create)
+```bash
+python test_deployment.py
+```
 
----
+## License
 
-**Note:** All endpoints requiring authentication expect a Bearer token in the `Authorization` header.  
-**Credit-guarded endpoints** will decrement user credits atomically and return an error if insufficient.
+Apache 2.0

check_deployment.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""
-Deployment troubleshooting script for 3DAI API Backend
-Run this script to check your deployment configuration
-"""
-
-import os
-import sys
-from dotenv import load_dotenv
-
-def check_environment_variables():
-    """Check if all required environment variables are set"""
-    print("🔍 Checking Environment Variables...")
-    
-    required_vars = [
-        "SUPABASE_URL",
-        "SUPABASE_KEY", 
-        "OPENAI_API_KEY",
-        "STRIPE_SECRET_KEY"
-    ]
-    
-    optional_vars = [
-        "JWT_SECRET_KEY"
-    ]
-    
-    missing_vars = []
-    
-    for var in required_vars:
-        value = os.getenv(var)
-        if not value:
-            missing_vars.append(var)
-            print(f"❌ {var}: Not set")
-        else:
-            # Show partial value for security
-            masked_value = value[:8] + "..." if len(value) > 8 else "***"
-            print(f"✅ {var}: {masked_value}")
-    
-    for var in optional_vars:
-        value = os.getenv(var)
-        if not value:
-            print(f"⚠️  {var}: Not set (using default)")
-        else:
-            masked_value = value[:8] + "..." if len(value) > 8 else "***"
-            print(f"✅ {var}: {masked_value}")
-    
-    return missing_vars
-
-def check_dependencies():
-    """Check if all required Python packages are installed"""
-    print("\n📦 Checking Dependencies...")
-    
-    required_packages = [
-        "fastapi",
-        "uvicorn", 
-        "supabase",
-        "httpx",
-        "stripe",
-        "pydantic",
-        "python-jose",
-        "passlib"
-    ]
-    
-    missing_packages = []
-    
-    for package in required_packages:
-        try:
-            __import__(package.replace("-", "_"))
-            print(f"✅ {package}: Installed")
-        except ImportError:
-            missing_packages.append(package)
-            print(f"❌ {package}: Not installed")
-    
-    return missing_packages
-
-def check_supabase_connection():
-    """Test Supabase connection"""
-    print("\n🗄️  Testing Supabase Connection...")
-    
-    try:
-        from supabase import create_client
-        
-        url = os.getenv("SUPABASE_URL")
-        key = os.getenv("SUPABASE_KEY")
-        
-        if not url or not key:
-            print("❌ Supabase credentials not set")
-            return False
-            
-        client = create_client(url, key)
-        
-        # Test a simple query
-        result = client.from_("User").select("user_id").limit(1).execute()
-        print("✅ Supabase connection successful")
-        return True
-        
-    except Exception as e:
-        print(f"❌ Supabase connection failed: {str(e)}")
-        return False
-
-def main():
-    """Main troubleshooting function"""
-    print("🚀 3DAI API Backend Deployment Check")
-    print("=" * 50)
-    
-    # Load environment variables
-    load_dotenv()
-    
-    # Check environment variables
-    missing_env_vars = check_environment_variables()
-    
-    # Check dependencies
-    missing_packages = check_dependencies()
-    
-    # Check Supabase connection
-    supabase_ok = check_supabase_connection()
-    
-    # Summary
-    print("\n📋 Summary:")
-    print("=" * 30)
-    
-    if missing_env_vars:
-        print(f"❌ Missing environment variables: {', '.join(missing_env_vars)}")
-        print("   Fix: Set these in your deployment environment or .env file")
-    
-    if missing_packages:
-        print(f"❌ Missing packages: {', '.join(missing_packages)}")
-        print("   Fix: Run 'pip install -r requirements.txt'")
-    
-    if not supabase_ok:
-        print("❌ Supabase connection failed")
-        print("   Fix: Check your SUPABASE_URL and SUPABASE_KEY")
-    
-    if not missing_env_vars and not missing_packages and supabase_ok:
-        print("✅ All checks passed! Your deployment should work.")
-        print("\n🔧 If sync-supabase-user still doesn't work, check:")
-        print("   1. Network connectivity to your deployed service")
-        print("   2. API endpoint URL is correct")
-        print("   3. Check application logs for specific errors")
-        print("   4. Verify your Supabase database schema matches the code")
-    else:
-        print("\n❌ Issues found. Fix the above problems and try again.")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main() 

main.py

@@ -21,7 +21,7 @@ dev_mode = False
 
 class Settings:
     def __init__(self):
-        self.mesh_api_key = "msy_slVFWXjDQvc2BR8ltSacK79YshK9KCXkaV3F"
+        self.mesh_api_key = os.getenv("MESHY_API_KEY")
         if not self.mesh_api_key:
             raise RuntimeError("MESHY_API_KEY environment variable not set")
         self.openai_api_key = os.getenv("OPENAI_API_KEY")

simple_test.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+Simple backend test to diagnose connection issues
+"""
+
+import requests
+import json
+from urllib3.exceptions import InsecureRequestWarning
+import urllib3
+
+# Disable SSL warnings for testing
+urllib3.disable_warnings(InsecureRequestWarning)
+
+def test_backend(url):
+    """Test backend with browser-like headers"""
+    print(f"🔍 Testing backend at: {url}")
+    
+    # Create session with browser-like headers
+    session = requests.Session()
+    session.headers.update({
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Accept': 'application/json, text/plain, */*',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Accept-Encoding': 'gzip, deflate, br',
+        'Connection': 'keep-alive',
+        'Upgrade-Insecure-Requests': '1',
+    })
+    
+    try:
+        print("📡 Making request...")
+        response = session.get(url, timeout=30, verify=False)
+        
+        print(f"✅ Status Code: {response.status_code}")
+        print(f"📄 Response Headers:")
+        for key, value in response.headers.items():
+            print(f"   {key}: {value}")
+        
+        print(f"📝 Response Content:")
+        print(f"   {response.text}")
+        
+        if response.status_code == 200:
+            try:
+                json_data = response.json()
+                print(f"✅ Valid JSON response: {json_data}")
+                return True
+            except:
+                print("⚠️  Response is not valid JSON")
+                return True
+        else:
+            print(f"❌ Non-200 status code: {response.status_code}")
+            return False
+            
+    except requests.exceptions.Timeout:
+        print("❌ Request timed out (30 seconds)")
+        return False
+    except requests.exceptions.ConnectionError as e:
+        print(f"❌ Connection error: {str(e)}")
+        return False
+    except requests.exceptions.SSLError as e:
+        print(f"❌ SSL error: {str(e)}")
+        return False
+    except Exception as e:
+        print(f"❌ Unexpected error: {str(e)}")
+        return False
+
+def test_multiple_endpoints(base_url):
+    """Test multiple endpoints"""
+    endpoints = [
+        "/",
+        "/docs", 
+        "/openapi.json",
+        "/auth/signup",
+    ]
+    
+    results = {}
+    
+    for endpoint in endpoints:
+        url = f"{base_url.rstrip('/')}{endpoint}"
+        print(f"\n🎯 Testing endpoint: {endpoint}")
+        print("-" * 40)
+        
+        if endpoint == "/auth/signup":
+            # Test with POST method
+            try:
+                session = requests.Session()
+                session.headers.update({
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                    'Content-Type': 'application/json',
+                })
+                
+                response = session.post(url, 
+                    json={"email": "test@example.com", "password": "test123"}, 
+                    timeout=30, 
+                    verify=False
+                )
+                print(f"Status: {response.status_code}")
+                print(f"Response: {response.text[:200]}...")
+                results[endpoint] = response.status_code < 500
+            except Exception as e:
+                print(f"Error: {str(e)}")
+                results[endpoint] = False
+        else:
+            # Test with GET method
+            results[endpoint] = test_backend(url)
+    
+    return results
+
+if __name__ == "__main__":
+    base_url = "https://maxjski-3dai.hf.space"
+    
+    print("🚀 Simple Backend Diagnostic Tool")
+    print("=" * 50)
+    
+    # Test main endpoint first
+    main_works = test_backend(base_url)
+    
+    if main_works:
+        print(f"\n✅ Main endpoint works! Testing other endpoints...")
+        results = test_multiple_endpoints(base_url)
+        
+        print(f"\n📊 Summary:")
+        for endpoint, status in results.items():
+            status_text = "✅ Working" if status else "❌ Issues"
+            print(f"   {endpoint}: {status_text}")
+    else:
+        print(f"\n❌ Main endpoint has issues. Check your deployment.") 

test_deployment.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""
+Comprehensive test script for 3DAI API Backend deployment
+Tests all endpoints to verify they're working properly
+"""
+
+import requests
+import json
+import time
+import os
+from typing import Optional, Dict, Any
+
+class BackendTester:
+    def __init__(self, base_url: str):
+        self.base_url = base_url.rstrip('/')
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Content-Type': 'application/json',
+            'User-Agent': '3DAI-Backend-Tester/1.0'
+        })
+        
+    def test_health_check(self) -> bool:
+        """Test the basic health check endpoint"""
+        print("🏥 Testing Health Check...")
+        try:
+            response = self.session.get(f"{self.base_url}/", timeout=10)
+            if response.status_code == 200:
+                print("✅ Health check passed")
+                print(f"   Response: {response.json()}")
+                return True
+            else:
+                print(f"❌ Health check failed with status {response.status_code}")
+                print(f"   Response: {response.text}")
+                return False
+        except Exception as e:
+            print(f"❌ Health check failed: {str(e)}")
+            return False
+    
+    def test_docs_endpoint(self) -> bool:
+        """Test if the API documentation is accessible"""
+        print("\n📚 Testing API Documentation...")
+        try:
+            response = self.session.get(f"{self.base_url}/docs", timeout=10)
+            if response.status_code == 200:
+                print("✅ API docs accessible")
+                return True
+            else:
+                print(f"❌ API docs failed with status {response.status_code}")
+                return False
+        except Exception as e:
+            print(f"❌ API docs failed: {str(e)}")
+            return False
+    
+    def test_openapi_spec(self) -> bool:
+        """Test if the OpenAPI specification is accessible"""
+        print("\n🔧 Testing OpenAPI Specification...")
+        try:
+            response = self.session.get(f"{self.base_url}/openapi.json", timeout=10)
+            if response.status_code == 200:
+                print("✅ OpenAPI spec accessible")
+                spec = response.json()
+                print(f"   API Title: {spec.get('info', {}).get('title', 'N/A')}")
+                print(f"   API Version: {spec.get('info', {}).get('version', 'N/A')}")
+                print(f"   Available endpoints: {len(spec.get('paths', {}))}")
+                return True
+            else:
+                print(f"❌ OpenAPI spec failed with status {response.status_code}")
+                return False
+        except Exception as e:
+            print(f"❌ OpenAPI spec failed: {str(e)}")
+            return False
+    
+    def test_signup_endpoint(self) -> Optional[Dict[str, Any]]:
+        """Test the signup endpoint"""
+        print("\n👤 Testing Signup Endpoint...")
+        try:
+            test_email = f"test_{int(time.time())}@example.com"
+            test_password = "TestPassword123!"
+            
+            payload = {
+                "email": test_email,
+                "password": test_password
+            }
+            
+            response = self.session.post(
+                f"{self.base_url}/auth/signup", 
+                json=payload, 
+                timeout=15
+            )
+            
+            if response.status_code in [200, 201]:
+                print("✅ Signup endpoint working")
+                result = response.json()
+                print(f"   Created user: {result.get('user', {}).get('email', 'unknown')}")
+                return result
+            else:
+                print(f"❌ Signup failed with status {response.status_code}")
+                print(f"   Response: {response.text}")
+                return None
+        except Exception as e:
+            print(f"❌ Signup test failed: {str(e)}")
+            return None
+    
+    def test_signin_endpoint(self, email: str, password: str) -> Optional[str]:
+        """Test the signin endpoint"""
+        print("\n🔐 Testing Signin Endpoint...")
+        try:
+            payload = {
+                "email": email,
+                "password": password
+            }
+            
+            response = self.session.post(
+                f"{self.base_url}/auth/signin", 
+                json=payload, 
+                timeout=15
+            )
+            
+            if response.status_code == 200:
+                print("✅ Signin endpoint working")
+                result = response.json()
+                token = result.get('access_token')
+                if token:
+                    print(f"   Token received: {token[:20]}...")
+                    return token
+                else:
+                    print("   ⚠️ No token in response")
+                    return None
+            else:
+                print(f"❌ Signin failed with status {response.status_code}")
+                print(f"   Response: {response.text}")
+                return None
+        except Exception as e:
+            print(f"❌ Signin test failed: {str(e)}")
+            return None
+    
+    def test_sync_supabase_user_endpoint(self, token: str) -> bool:
+        """Test the sync-supabase-user endpoint"""
+        print("\n🔄 Testing Sync Supabase User Endpoint...")
+        try:
+            headers = {"Authorization": f"Bearer {token}"}
+            payload = {
+                "supabase_user_id": "test_user_id",
+                "email": "test@example.com",
+                "full_name": "Test User"
+            }
+            
+            response = self.session.post(
+                f"{self.base_url}/auth/sync-supabase-user", 
+                json=payload, 
+                headers=headers,
+                timeout=15
+            )
+            
+            if response.status_code in [200, 201]:
+                print("✅ Sync Supabase User endpoint working")
+                result = response.json()
+                print(f"   Message: {result.get('message', 'No message')}")
+                return True
+            else:
+                print(f"❌ Sync Supabase User failed with status {response.status_code}")
+                print(f"   Response: {response.text}")
+                return False
+        except Exception as e:
+            print(f"❌ Sync Supabase User test failed: {str(e)}")
+            return False
+    
+    def test_protected_endpoint(self, token: str) -> bool:
+        """Test a protected endpoint (user profile)"""
+        print("\n🛡️  Testing Protected Endpoint (User Profile)...")
+        try:
+            headers = {"Authorization": f"Bearer {token}"}
+            
+            response = self.session.get(
+                f"{self.base_url}/user/profile",
+                headers=headers,
+                timeout=15
+            )
+            
+            if response.status_code == 200:
+                print("✅ Protected endpoint working")
+                result = response.json()
+                print(f"   Profile data received: {len(str(result))} characters")
+                return True
+            else:
+                print(f"❌ Protected endpoint failed with status {response.status_code}")
+                print(f"   Response: {response.text}")
+                return False
+        except Exception as e:
+            print(f"❌ Protected endpoint test failed: {str(e)}")
+            return False
+    
+    def test_cors_headers(self) -> bool:
+        """Test CORS headers"""
+        print("\n🌐 Testing CORS Headers...")
+        try:
+            response = self.session.options(f"{self.base_url}/", timeout=10)
+            cors_headers = {
+                'Access-Control-Allow-Origin': response.headers.get('Access-Control-Allow-Origin'),
+                'Access-Control-Allow-Methods': response.headers.get('Access-Control-Allow-Methods'),
+                'Access-Control-Allow-Headers': response.headers.get('Access-Control-Allow-Headers'),
+            }
+            
+            if any(cors_headers.values()):
+                print("✅ CORS headers present")
+                for header, value in cors_headers.items():
+                    if value:
+                        print(f"   {header}: {value}")
+                return True
+            else:
+                print("⚠️  No CORS headers found")
+                return False
+        except Exception as e:
+            print(f"❌ CORS test failed: {str(e)}")
+            return False
+
+def main():
+    """Main testing function"""
+    print("🚀 3DAI API Backend Deployment Test Suite")
+    print("=" * 60)
+    
+    # Get base URL from user input or environment
+    base_url = input("Enter your deployed backend URL (e.g., https://your-app.hf.space): ").strip()
+    
+    if not base_url:
+        print("❌ No URL provided. Exiting.")
+        return
+    
+    # Initialize tester
+    tester = BackendTester(base_url)
+    
+    # Run tests
+    print(f"\n🎯 Testing backend at: {base_url}")
+    print("-" * 60)
+    
+    # Basic connectivity tests
+    health_ok = tester.test_health_check()
+    docs_ok = tester.test_docs_endpoint()
+    openapi_ok = tester.test_openapi_spec()
+    cors_ok = tester.test_cors_headers()
+    
+    # Authentication tests
+    signup_result = tester.test_signup_endpoint()
+    token = None
+    signin_ok = False
+    sync_ok = False
+    protected_ok = False
+    
+    if signup_result and signup_result.get('user'):
+        # Try to sign in with the created user
+        user_email = signup_result['user']['email']
+        token = tester.test_signin_endpoint(user_email, "TestPassword123!")
+        signin_ok = token is not None
+        
+        if token:
+            # Test sync endpoint
+            sync_ok = tester.test_sync_supabase_user_endpoint(token)
+            
+            # Test protected endpoint
+            protected_ok = tester.test_protected_endpoint(token)
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print("📊 TEST RESULTS SUMMARY")
+    print("=" * 60)
+    
+    basic_tests = [
+        ("Health Check", health_ok),
+        ("API Documentation", docs_ok), 
+        ("OpenAPI Specification", openapi_ok),
+        ("CORS Headers", cors_ok),
+    ]
+    
+    auth_tests = [
+        ("User Signup", signup_result is not None),
+        ("User Signin", signin_ok),
+        ("Sync Supabase User", sync_ok),
+        ("Protected Endpoint", protected_ok),
+    ]
+    
+    print("\n🔧 Basic Functionality:")
+    for test_name, result in basic_tests:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"   {test_name}: {status}")
+    
+    print("\n🔐 Authentication & Authorization:")
+    for test_name, result in auth_tests:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"   {test_name}: {status}")
+    
+    # Overall status
+    all_basic_pass = all(result for _, result in basic_tests)
+    some_auth_pass = any(result for _, result in auth_tests)
+    
+    print("\n🎯 OVERALL STATUS:")
+    if all_basic_pass and some_auth_pass:
+        print("✅ Backend is working! Most functionality is operational.")
+    elif all_basic_pass:
+        print("⚠️  Backend is partially working. Basic endpoints work but authentication has issues.")
+    elif health_ok:
+        print("⚠️  Backend is running but has significant issues.")
+    else:
+        print("❌ Backend appears to be down or not accessible.")
+    
+    # Recommendations
+    print("\n💡 RECOMMENDATIONS:")
+    if not health_ok:
+        print("   1. Check if your backend is actually deployed and running")
+        print("   2. Verify the URL is correct")
+        print("   3. Check deployment logs for errors")
+    elif not some_auth_pass:
+        print("   1. Check environment variables (SUPABASE_URL, SUPABASE_KEY, etc.)")
+        print("   2. Verify database connectivity")
+        print("   3. Check authentication service configuration")
+    elif not sync_ok:
+        print("   1. The sync-supabase-user endpoint specifically has issues")
+        print("   2. Check database schema (User and User_Credit_Account tables)")
+        print("   3. Review application logs for specific errors")
+    else:
+        print("   1. Your backend appears to be working well!")
+        print("   2. Test with real data and scenarios")
+        print("   3. Monitor performance and error rates")
+
+if __name__ == "__main__":
+    main() 

test_endpoints.sh

@@ -0,0 +1,104 @@
+#!/bin/bash
+# Quick endpoint testing script using curl
+# Usage: ./test_endpoints.sh <your-backend-url>
+
+BASE_URL=${1:-"http://localhost:7860"}
+BASE_URL=${BASE_URL%/}  # Remove trailing slash
+
+echo "🚀 Testing 3DAI API Backend at: $BASE_URL"
+echo "=" * 60
+
+# Test 1: Health Check
+echo "🏥 Testing Health Check..."
+curl -s -w "Status: %{http_code}\n" "$BASE_URL/" | head -10
+echo ""
+
+# Test 2: API Documentation
+echo "📚 Testing API Documentation..."
+curl -s -I "$BASE_URL/docs" | grep "HTTP"
+echo ""
+
+# Test 3: OpenAPI Specification
+echo "🔧 Testing OpenAPI Specification..."
+curl -s -w "Status: %{http_code}\n" "$BASE_URL/openapi.json" | head -5
+echo ""
+
+# Test 4: Signup (this will create a test user)
+echo "👤 Testing Signup..."
+TEST_EMAIL="test_$(date +%s)@example.com"
+SIGNUP_RESPONSE=$(curl -s -w "HTTPSTATUS:%{http_code}" -X POST "$BASE_URL/auth/signup" \
+  -H "Content-Type: application/json" \
+  -d "{\"email\":\"$TEST_EMAIL\",\"password\":\"TestPassword123!\"}")
+
+HTTP_STATUS=$(echo $SIGNUP_RESPONSE | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
+SIGNUP_BODY=$(echo $SIGNUP_RESPONSE | sed -E 's/HTTPSTATUS:[0-9]{3}$//')
+
+echo "Status: $HTTP_STATUS"
+echo "Response: $SIGNUP_BODY" | head -3
+echo ""
+
+# Test 5: Signin (if signup worked)
+if [ "$HTTP_STATUS" = "200" ] || [ "$HTTP_STATUS" = "201" ]; then
+    echo "🔐 Testing Signin..."
+    SIGNIN_RESPONSE=$(curl -s -w "HTTPSTATUS:%{http_code}" -X POST "$BASE_URL/auth/signin" \
+      -H "Content-Type: application/json" \
+      -d "{\"email\":\"$TEST_EMAIL\",\"password\":\"TestPassword123!\"}")
+    
+    SIGNIN_HTTP_STATUS=$(echo $SIGNIN_RESPONSE | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
+    SIGNIN_BODY=$(echo $SIGNIN_RESPONSE | sed -E 's/HTTPSTATUS:[0-9]{3}$//')
+    
+    echo "Status: $SIGNIN_HTTP_STATUS"
+    
+    if [ "$SIGNIN_HTTP_STATUS" = "200" ]; then
+        # Extract token
+        TOKEN=$(echo $SIGNIN_BODY | grep -o '"access_token":"[^"]*' | cut -d'"' -f4)
+        echo "Token received: ${TOKEN:0:20}..."
+        echo ""
+        
+        # Test 6: Sync Supabase User
+        echo "🔄 Testing Sync Supabase User..."
+        SYNC_RESPONSE=$(curl -s -w "HTTPSTATUS:%{http_code}" -X POST "$BASE_URL/auth/sync-supabase-user" \
+          -H "Content-Type: application/json" \
+          -H "Authorization: Bearer $TOKEN" \
+          -d "{\"supabase_user_id\":\"test_user_id\",\"email\":\"$TEST_EMAIL\",\"full_name\":\"Test User\"}")
+        
+        SYNC_HTTP_STATUS=$(echo $SYNC_RESPONSE | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
+        SYNC_BODY=$(echo $SYNC_RESPONSE | sed -E 's/HTTPSTATUS:[0-9]{3}$//')
+        
+        echo "Status: $SYNC_HTTP_STATUS"
+        echo "Response: $SYNC_BODY" | head -3
+        echo ""
+        
+        # Test 7: Protected endpoint
+        echo "🛡️  Testing Protected Endpoint (User Profile)..."
+        PROFILE_RESPONSE=$(curl -s -w "HTTPSTATUS:%{http_code}" -X GET "$BASE_URL/user/profile" \
+          -H "Authorization: Bearer $TOKEN")
+        
+        PROFILE_HTTP_STATUS=$(echo $PROFILE_RESPONSE | tr -d '\n' | sed -e 's/.*HTTPSTATUS://')
+        PROFILE_BODY=$(echo $PROFILE_RESPONSE | sed -E 's/HTTPSTATUS:[0-9]{3}$//')
+        
+        echo "Status: $PROFILE_HTTP_STATUS"
+        echo "Response: $PROFILE_BODY" | head -3
+        echo ""
+    else
+        echo "Signin failed, skipping protected endpoint tests"
+        echo ""
+    fi
+else
+    echo "Signup failed, skipping signin and protected endpoint tests"
+    echo ""
+fi
+
+echo "✅ Testing complete!"
+echo ""
+echo "💡 Quick Status Check:"
+echo "- Health endpoint working: Check if you see 'message': 'API is running' above"
+echo "- Signup working: Check if signup status was 200/201"
+echo "- Signin working: Check if signin status was 200"
+echo "- Sync endpoint working: Check if sync status was 200/201"
+echo ""
+echo "🔧 If endpoints are failing:"
+echo "1. Verify your backend URL is correct"
+echo "2. Check if environment variables are set properly"
+echo "3. Look at deployment logs for errors"
+echo "4. Use the Python test script for more detailed testing: python test_deployment.py"