setup reminders for user

backend/app/services/sms_sender.py

@@ -96,13 +96,16 @@ class SMSSender:
     ) -> Dict[str, Any]:
         """Send SMS via Twilio."""
         try:
+            logger.info(f"Attempting to send SMS via Twilio to {masked_phone}")
+            logger.debug(f"From: {settings.TWILIO_FROM_NUMBER}, To: {to_number}")
+            
             result = self.twilio_client.messages.create(
                 body=message,
                 from_=settings.TWILIO_FROM_NUMBER,
                 to=to_number
             )
             
-            logger.info(f"SMS sent via Twilio to {masked_phone} (user_id={user_id}, sid={result.sid})")
+            logger.info(f"✅ SMS sent via Twilio to {masked_phone} (user_id={user_id}, sid={result.sid})")
             
             return {
                 "success": True,
@@ -117,7 +120,7 @@ class SMSSender:
             }
             
         except Exception as e:
-            logger.error(f"Twilio SMS failed to {masked_phone} (user_id={user_id}): {str(e)}")
+            logger.error(f"❌ Twilio SMS failed to {masked_phone} (user_id={user_id}): {type(e).__name__}: {str(e)}")
             return {
                 "success": False,
                 "status": "failed",

backend/app/settings.py

@@ -87,3 +87,13 @@ class Settings(BaseSettings):
 
 settings = Settings()
 
+# Debug logging to verify SMS configuration
+import logging
+logger = logging.getLogger(__name__)
+logger.info(f"SMS Configuration loaded:")
+logger.info(f"  SMS_MODE: {settings.SMS_MODE}")
+logger.info(f"  SMS_TEST_TO_NUMBER: {settings.SMS_TEST_TO_NUMBER}")
+logger.info(f"  TWILIO_ACCOUNT_SID configured: {bool(settings.TWILIO_ACCOUNT_SID)}")
+logger.info(f"  TWILIO_AUTH_TOKEN configured: {bool(settings.TWILIO_AUTH_TOKEN)}")
+logger.info(f"  TWILIO_FROM_NUMBER: {settings.TWILIO_FROM_NUMBER}")
+

backend/scripts/check_reminders.py

@@ -0,0 +1,34 @@
+import sys
+sys.path.insert(0, '/app')
+import asyncio
+from datetime import datetime
+from sqlalchemy import select
+from app.db import async_session_maker
+from app.models import Reminder
+
+async def check():
+    async with async_session_maker() as db:
+        result = await db.execute(
+            select(Reminder)
+            .where(Reminder.is_enabled == True)
+            .order_by(Reminder.next_run_at)
+        )
+        reminders = result.scalars().all()
+        
+        print('\n' + '='*70)
+        print('ACTIVE REMINDERS')
+        print('='*70)
+        
+        now = datetime.utcnow()
+        for r in reminders:
+            if r.next_run_at:
+                diff_secs = (r.next_run_at - now).total_seconds()
+                mins = int(diff_secs / 60)
+                status = 'OVERDUE' if diff_secs < 0 else f'{mins} min'
+                print(f'\n{r.title}')
+                print(f'  Type: {r.type} | Channel: {r.channel}')
+                print(f'  Next: {r.next_run_at.strftime("%H:%M UTC")} ({status})')
+        
+        print('\n' + '='*70 + '\n')
+
+asyncio.run(check())

backend/scripts/create_test_reminder.py

@@ -0,0 +1,92 @@
+"""
+Create Test Reminder for E2E Verification
+
+Creates a reminder that will fire in 2 minutes to test the full flow.
+Run inside Docker: docker exec ggw-backend python scripts/create_test_reminder.py
+"""
+import sys
+sys.path.insert(0, '/app')
+
+import asyncio
+from datetime import datetime, timedelta
+from uuid import uuid4
+from sqlalchemy import select
+from app.db import async_session_maker
+from app.models import User, UserProfile, Reminder
+from app.security import hash_password
+
+async def create_test_reminder():
+    """Create a test reminder that fires soon."""
+    
+    # Import inside function to ensure proper module loading
+    from app.db import async_session_maker
+    from app.models import User, UserProfile, Reminder
+    from sqlalchemy import select
+    
+    print("=" * 60)
+    print("CREATING TEST REMINDER")
+    print("=" * 60)
+    
+    async with async_session_maker() as db:
+        # Find a user with a phone number in their profile
+        result = await db.execute(
+            select(User).join(UserProfile).where(UserProfile.phone_number.isnot(None)).limit(1)
+        )
+        user = result.scalar_one_or_none()
+        
+        if not user:
+            print("\n❌ No user with phone number found!")
+            print("   Please create a user profile with a phone number first.")
+            
+            # List all users
+            all_users = await db.execute(select(User).limit(5))
+            users = list(all_users.scalars().all())
+            if users:
+                print("\n   Available users:")
+                for u in users:
+                    print(f"   - {u.email} (id: {u.id})")
+            return
+        
+        # Get user's profile
+        profile_result = await db.execute(
+            select(UserProfile).where(UserProfile.user_id == user.id)
+        )
+        profile = profile_result.scalar_one_or_none()
+        
+        print(f"\nFound user: {user.email}")
+        print(f"Phone number: ****{profile.phone_number[-4:] if profile and profile.phone_number else 'N/A'}")
+        
+        # Create a reminder that fires in 2 minutes
+        next_run = datetime.utcnow() + timedelta(minutes=2)
+        
+        reminder = Reminder(
+            user_id=user.id,
+            type="test",
+            title="🧪 Test Reminder",
+            message="This is a test reminder from Lumea Health! If you received this, the SMS system is working correctly.",
+            schedule_type="fixed_times",
+            schedule_json={"times": [next_run.strftime("%H:%M")]},
+            timezone="UTC",
+            channel="sms",
+            is_enabled=True,
+            next_run_at=next_run
+        )
+        
+        db.add(reminder)
+        await db.commit()
+        await db.refresh(reminder)
+        
+        print(f"\n✅ Created test reminder!")
+        print(f"   ID: {reminder.id}")
+        print(f"   Title: {reminder.title}")
+        print(f"   Next Run: {reminder.next_run_at} UTC")
+        print(f"   (approximately {2} minutes from now)")
+        
+        print(f"\n⏰ The reminder scheduler runs every 60 seconds.")
+        print(f"   Watch the logs: docker logs -f ggw-backend 2>&1 | grep -i 'reminder\\|SMS\\|twilio'")
+        
+        return reminder
+
+
+if __name__ == "__main__":
+    asyncio.run(create_test_reminder())

backend/scripts/generate_health_reminders.py

@@ -0,0 +1,151 @@
+"""
+Generate Health Reminders for Existing Users
+
+Creates reminders based on user profile data:
+- Hydration reminders
+- Sleep reminders
+- Medicine reminders (if any)
+- Exercise reminders
+"""
+import sys
+sys.path.insert(0, '/app')
+
+import asyncio
+from datetime import datetime, timedelta, time as dt_time
+from sqlalchemy import select
+from app.db import async_session_maker
+from app.models import User, UserProfile, Reminder
+from app.services.reminder_service import ReminderService
+
+async def generate_reminders():
+    print("=" * 70)
+    print("GENERATING HEALTH REMINDERS")
+    print("=" * 70)
+    
+    async with async_session_maker() as db:
+        # Get all users with profiles and phone numbers
+        result = await db.execute(
+            select(User, UserProfile)
+            .join(UserProfile)
+            .where(UserProfile.phone_number.isnot(None))
+        )
+        users = result.all()
+        
+        if not users:
+            print("\n❌ No users with phone numbers found!")
+            return
+        
+        print(f"\nFound {len(users)} user(s) with phone numbers")
+        
+        for user, profile in users:
+            print(f"\n{'─' * 70}")
+            print(f"User: {user.email}")
+            print(f"Phone: {profile.phone_number}")
+            print(f"Age: {profile.age_years}, Activity: {profile.activity_level or 'not set'}")
+            
+            # Delete old non-medicine reminders
+            result = await db.execute(
+                select(Reminder)
+                .where(Reminder.user_id == user.id)
+                .where(Reminder.type.in_(['hydration', 'sleep', 'exercise', 'test']))
+            )
+            old_reminders = list(result.scalars().all())
+            for r in old_reminders:
+                await db.delete(r)
+            await db.commit()
+            print(f"  Cleaned up {len(old_reminders)} old reminder(s)")
+            
+            reminders_created = []
+            
+            # 1. HYDRATION REMINDER - Every 2 hours during day
+            print("\n  Creating hydration reminders...")
+            now = datetime.utcnow()
+            # Schedule next hydration in 3 minutes for testing
+            next_hydration = now + timedelta(minutes=3)
+            
+            hydration = Reminder(
+                user_id=user.id,
+                type='hydration',
+                title='💧 Stay Hydrated',
+                message='Time to drink water! Staying hydrated helps maintain energy and focus throughout the day. 🚰',
+                schedule_type='interval',
+                schedule_json={
+                    'interval_minutes': 120,  # Every 2 hours
+                    'start_time': '08:00',
+                    'end_time': '22:00'
+                },
+                timezone='Asia/Kolkata',
+                channel='sms',
+                is_enabled=True,
+                next_run_at=next_hydration
+            )
+            db.add(hydration)
+            reminders_created.append(('💧 Hydration', next_hydration))
+            
+            # 2. SLEEP REMINDER - Every night
+            print("  Creating sleep reminder...")
+            # Calculate next 22:00 or tomorrow if passed
+            now_hour = now.hour
+            if now_hour >= 22:
+                next_sleep = (now + timedelta(days=1)).replace(hour=22, minute=0, second=0, microsecond=0)
+            else:
+                next_sleep = now.replace(hour=22, minute=0, second=0, microsecond=0)
+            
+            # For testing, set to 5 minutes from now
+            next_sleep = now + timedelta(minutes=5)
+            
+            sleep = Reminder(
+                user_id=user.id,
+                type='sleep',
+                title='🌙 Time for Bed',
+                message=f'Wind down time! Aim for 7-8 hours of quality sleep for better health. Good night! 😴',
+                schedule_type='fixed_times',
+                schedule_json={'times': ['22:00']},
+                timezone='Asia/Kolkata',
+                channel='sms',
+                is_enabled=True,
+                next_run_at=next_sleep
+            )
+            db.add(sleep)
+            reminders_created.append(('🌙 Sleep', next_sleep))
+            
+            # 3. EXERCISE REMINDER - if sedentary
+            if profile.activity_level in ['sedentary', None]:
+                print("  Creating exercise reminder...")
+                # Set to 7 minutes from now for testing
+                next_exercise = now + timedelta(minutes=7)
+                
+                exercise = Reminder(
+                    user_id=user.id,
+                    type='exercise',
+                    title='🏃 Get Moving!',
+                    message='Time for some movement! A short 10-minute walk or stretch can boost your energy and improve your health. 💪',
+                    schedule_type='fixed_times',
+                    schedule_json={'times': ['10:00', '15:00']},
+                    timezone='Asia/Kolkata',
+                    channel='sms',
+                    is_enabled=True,
+                    next_run_at=next_exercise
+                )
+                db.add(exercise)
+                reminders_created.append(('🏃 Exercise', next_exercise))
+            
+            await db.commit()
+            
+            print(f"\n  ✅ Created {len(reminders_created)} reminders:")
+            for title, next_run in reminders_created:
+                minutes_until = (next_run - now).total_seconds() / 60
+                print(f"     {title}: fires in {int(minutes_until)} minutes ({next_run.strftime('%H:%M UTC')})")
+    
+    print(f"\n{'=' * 70}")
+    print("✅ REMINDER GENERATION COMPLETE!")
+    print("=" * 70)
+    print("\n📱 Reminders will be sent via SMS")
+    print("🔍 Monitor logs: docker logs -f ggw-backend 2>&1 | grep -i reminder")
+    print(f"\n⏰ Next reminders:")
+    print(f"   - Hydration: ~3 minutes")
+    print(f"   - Sleep: ~5 minutes")
+    print(f"   - Exercise: ~7 minutes")
+    print("\n" + "=" * 70)
+
+asyncio.run(generate_reminders())

backend/scripts/test_reminder_system.py

@@ -0,0 +1,206 @@
+"""
+Complete Reminder System Test
+
+This script:
+1. Creates a test user with profile and phone number
+2. Creates a reminder that fires in the next 2-3 minutes
+3. Verifies the reminder scheduler picks it up and sends SMS
+
+Run from backend directory:
+    python scripts/test_reminder_system.py
+"""
+import asyncio
+import sys
+from pathlib import Path
+from datetime import datetime, timedelta
+from uuid import uuid4
+
+# Add the backend directory to path
+backend_dir = Path(__file__).parent.parent
+sys.path.insert(0, str(backend_dir))
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv(backend_dir / ".env")
+
+from sqlalchemy import select
+from app.db import async_session_maker, init_db
+from app.models import User, UserProfile, Reminder
+from app.security import hash_password
+
+
+async def create_test_user_and_reminder():
+    """Create a test user with profile and a reminder that fires soon."""
+    
+    print("=" * 70)
+    print("CO-CODE REMINDER SYSTEM TEST")
+    print("=" * 70)
+    
+    # Initialize database
+    print("\n1. Initializing database...")
+    await init_db()
+    print("   ✅ Database initialized")
+    
+    async with async_session_maker() as db:
+        # Check for existing test user
+        print("\n2. Creating/finding test user...")
+        result = await db.execute(
+            select(User).where(User.email == "reminder_test@cocode.com")
+        )
+        user = result.scalar_one_or_none()
+        
+        if user:
+            print(f"   ℹ️  Found existing test user: {user.email} (ID: {user.id})")
+        else:
+            # Create test user
+            user = User(
+                id=uuid4(),
+                email="reminder_test@cocode.com",
+                full_name="Reminder Test User",
+                password_hash=hash_password("testpass123"),
+                is_active=True
+            )
+            db.add(user)
+            await db.commit()
+            await db.refresh(user)
+            print(f"   ✅ Created test user: {user.email} (ID: {user.id})")
+        
+        # Check for profile
+        print("\n3. Creating/updating user profile...")
+        result = await db.execute(
+            select(UserProfile).where(UserProfile.user_id == user.id)
+        )
+        profile = result.scalar_one_or_none()
+        
+        # Get phone number from environment
+        import os
+        phone_number = os.getenv("SMS_TEST_TO_NUMBER", "+919004281995")
+        
+        if profile:
+            profile.phone_number = phone_number
+            profile.full_name = "Reminder Test User"
+            profile.age_years = 30
+            print(f"   ℹ️  Updated existing profile with phone: {phone_number}")
+        else:
+            profile = UserProfile(
+                user_id=user.id,
+                full_name="Reminder Test User",
+                phone_number=phone_number,
+                age_years=30,
+                sex_at_birth="male",
+                height_cm=175,
+                weight_kg=70
+            )
+            db.add(profile)
+            print(f"   ✅ Created profile with phone: {phone_number}")
+        
+        await db.commit()
+        await db.refresh(profile)
+        
+        # Delete any existing test reminders for this user
+        print("\n4. Cleaning up old test reminders...")
+        result = await db.execute(
+            select(Reminder).where(Reminder.user_id == user.id)
+        )
+        old_reminders = list(result.scalars().all())
+        for reminder in old_reminders:
+            await db.delete(reminder)
+        await db.commit()
+        print(f"   ✅ Deleted {len(old_reminders)} old reminder(s)")
+        
+        # Create a new reminder that fires in 2 minutes
+        print("\n5. Creating test reminder...")
+        next_run = datetime.utcnow() + timedelta(minutes=2)
+        
+        reminder = Reminder(
+            user_id=user.id,
+            type="test",
+            title="🧪 Test Reminder",
+            message=f"This is a test reminder from Co-Code! If you receive this SMS, the reminder system is working perfectly. Time: {datetime.utcnow().strftime('%H:%M:%S UTC')}",
+            schedule_type="once",
+            schedule_json={"time": next_run.isoformat()},
+            timezone="UTC",
+            channel="sms",
+            is_enabled=True,
+            next_run_at=next_run
+        )
+        
+        db.add(reminder)
+        await db.commit()
+        await db.refresh(reminder)
+        
+        print(f"   ✅ Created test reminder:")
+        print(f"      ID: {reminder.id}")
+        print(f"      Title: {reminder.title}")
+        print(f"      Next run: {next_run.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+        print(f"      Phone: {phone_number}")
+        
+        # Calculate time until reminder fires
+        seconds_until = (next_run - datetime.utcnow()).total_seconds()
+        minutes = int(seconds_until // 60)
+        seconds = int(seconds_until % 60)
+        
+        print(f"\n{'=' * 70}")
+        print(f"⏰ REMINDER WILL FIRE IN: {minutes} minutes and {seconds} seconds")
+        print(f"{'=' * 70}")
+        print(f"\n📱 Watch for SMS to: {phone_number}")
+        print(f"📋 Check Docker logs: docker logs ggw-backend -f")
+        print(f"🔍 Look for: 'Reminder scheduler tick: processed'")
+        print(f"\nThe reminder scheduler checks every 60 seconds.")
+        print(f"Your reminder will be sent at approximately: {next_run.strftime('%H:%M:%S UTC')}")
+        print(f"\n{'=' * 70}\n")
+        
+        return {
+            "user_id": str(user.id),
+            "reminder_id": str(reminder.id),
+            "phone_number": phone_number,
+            "next_run": next_run.isoformat(),
+            "seconds_until": int(seconds_until)
+        }
+
+
+async def monitor_logs():
+    """Monitor Docker logs for reminder processing."""
+    print("\n🔍 Monitoring logs for reminder processing...")
+    print("   (Press Ctrl+C to stop)\n")
+    
+    import subprocess
+    
+    try:
+        process = subprocess.Popen(
+            ["docker", "logs", "ggw-backend", "-f"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1
+        )
+        
+        for line in process.stdout:
+            if any(keyword in line.lower() for keyword in ["reminder", "sms", "twilio", "processed"]):
+                print(f"   {line.strip()}")
+        
+    except KeyboardInterrupt:
+        print("\n\n   Monitoring stopped by user")
+        process.kill()
+
+
+if __name__ == "__main__":
+    try:
+        result = asyncio.run(create_test_user_and_reminder())
+        
+        print("\n" + "=" * 70)
+        print("TEST SETUP COMPLETE!")
+        print("=" * 70)
+        print("\nWould you like to monitor logs? (Y/n): ", end="")
+        
+        choice = input().strip().lower()
+        if choice in ["", "y", "yes"]:
+            asyncio.run(monitor_logs())
+        else:
+            print("\n✅ Setup complete. Check SMS and Docker logs in ~2 minutes.")
+    
+    except Exception as e:
+        print(f"\n❌ ERROR: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)

backend/scripts/test_sms_api.py

@@ -0,0 +1,91 @@
+"""
+Test SMS API Endpoint in Docker
+
+Tests the /api/sms/test endpoint by logging in and sending a test SMS.
+"""
+import httpx
+import asyncio
+
+BASE_URL = "http://localhost:8000"
+
+
+async def test_sms_via_api():
+    """Test SMS sending via API endpoint."""
+    
+    print("=" * 60)
+    print("TESTING SMS VIA API ENDPOINT")
+    print("=" * 60)
+    
+    async with httpx.AsyncClient() as client:
+        # Step 1: Login to get JWT token
+        print("\n1. Logging in to get JWT token...")
+        
+        # Try with a test user - you may need to create one first
+        login_data = {
+            "username": "test@example.com",  # Update with your test user
+            "password": "testpassword"       # Update with your test password
+        }
+        
+        try:
+            response = await client.post(
+                f"{BASE_URL}/api/auth/token",
+                data=login_data,
+                headers={"Content-Type": "application/x-www-form-urlencoded"}
+            )
+            
+            if response.status_code != 200:
+                print(f"   ❌ Login failed: {response.status_code}")
+                print(f"   Response: {response.text}")
+                print("\n   💡 Tip: You may need to register a user first or use existing credentials")
+                return False
+            
+            token_data = response.json()
+            token = token_data.get("access_token")
+            print(f"   ✅ Got JWT token: {token[:20]}...")
+            
+        except Exception as e:
+            print(f"   ❌ Login error: {e}")
+            return False
+        
+        # Step 2: Call the SMS test endpoint
+        print("\n2. Calling /api/sms/test endpoint...")
+        
+        try:
+            response = await client.post(
+                f"{BASE_URL}/api/sms/test",
+                json={"message": "🏥 Hello from API test! Lumea Health SMS is working."},
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Content-Type": "application/json"
+                }
+            )
+            
+            print(f"   Status Code: {response.status_code}")
+            result = response.json()
+            print(f"   Response: {result}")
+            
+            if response.status_code == 200 and result.get("success"):
+                print("\n✅ SMS test successful!")
+                return True
+            else:
+                print(f"\n❌ SMS test failed: {result.get('message', 'Unknown error')}")
+                return False
+                
+        except Exception as e:
+            print(f"   ❌ API call error: {e}")
+            return False
+
+
+if __name__ == "__main__":
+    print("\n" + "=" * 60)
+    print("LUMEA HEALTH - API SMS TEST")
+    print("=" * 60)
+    
+    success = asyncio.run(test_sms_via_api())
+    
+    print("\n" + "=" * 60)
+    if success:
+        print("✅ API SMS test completed successfully!")
+    else:
+        print("❌ API SMS test failed. Check configuration.")
+    print("=" * 60 + "\n")

backend/scripts/test_twilio_sms.py

@@ -0,0 +1,126 @@
+"""
+Test Twilio SMS Integration
+
+Simple standalone script to test Twilio SMS sending.
+Run from the backend directory:
+    python scripts/test_twilio_sms.py
+"""
+import os
+import sys
+from pathlib import Path
+
+# Add the backend directory to path
+backend_dir = Path(__file__).parent.parent
+sys.path.insert(0, str(backend_dir))
+
+# Load environment variables from .env
+from dotenv import load_dotenv
+load_dotenv(backend_dir / ".env")
+
+def test_twilio_sms():
+    """Test sending SMS via Twilio."""
+    
+    # Print configuration (mask sensitive data)
+    print("=" * 60)
+    print("TWILIO SMS TEST")
+    print("=" * 60)
+    
+    # Get credentials from environment
+    account_sid = os.getenv("TWILIO_ACCOUNT_SID")
+    auth_token = os.getenv("TWILIO_AUTH_TOKEN")
+    from_number = os.getenv("TWILIO_FROM_NUMBER")
+    to_number = os.getenv("SMS_TEST_TO_NUMBER")
+    sms_mode = os.getenv("SMS_MODE", "mock")
+    
+    print(f"\nConfiguration:")
+    print(f"  SMS_MODE: {sms_mode}")
+    print(f"  TWILIO_ACCOUNT_SID: {'***' + account_sid[-4:] if account_sid else 'NOT SET'}")
+    print(f"  TWILIO_AUTH_TOKEN: {'***' + auth_token[-4:] if auth_token else 'NOT SET'}")
+    print(f"  TWILIO_FROM_NUMBER: {from_number or 'NOT SET'}")
+    print(f"  SMS_TEST_TO_NUMBER: {to_number or 'NOT SET'}")
+    
+    # Validate configuration
+    if not all([account_sid, auth_token, from_number, to_number]):
+        print("\n❌ ERROR: Missing Twilio configuration!")
+        print("Please set all required environment variables in .env:")
+        print("  - TWILIO_ACCOUNT_SID")
+        print("  - TWILIO_AUTH_TOKEN")
+        print("  - TWILIO_FROM_NUMBER")
+        print("  - SMS_TEST_TO_NUMBER")
+        return False
+    
+    if sms_mode != "twilio":
+        print(f"\n⚠️  WARNING: SMS_MODE is '{sms_mode}', not 'twilio'")
+        print("   Change SMS_MODE=twilio in .env to send real SMS")
+        
+    print("\n" + "-" * 60)
+    print("Attempting to send test SMS...")
+    print("-" * 60)
+    
+    try:
+        from twilio.rest import Client
+        
+        client = Client(account_sid, auth_token)
+        
+        message = client.messages.create(
+            body="🏥 Lumea Health Test: Your Twilio SMS configuration is working correctly! This is a test message.",
+            from_=from_number,
+            to=to_number
+        )
+        
+        print(f"\n✅ SUCCESS! SMS sent successfully!")
+        print(f"   Message SID: {message.sid}")
+        print(f"   Status: {message.status}")
+        print(f"   From: {from_number}")
+        print(f"   To: {to_number}")
+        print(f"   Date Created: {message.date_created}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"\n❌ ERROR: Failed to send SMS")
+        print(f"   Error Type: {type(e).__name__}")
+        print(f"   Error Message: {str(e)}")
+        
+        # Common error explanations
+        error_msg = str(e).lower()
+        if "authenticate" in error_msg or "credentials" in error_msg:
+            print("\n   💡 Tip: Check your TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN")
+        elif "unverified" in error_msg:
+            print("\n   💡 Tip: In trial mode, you can only send to verified numbers.")
+            print("         Verify your phone number at: https://console.twilio.com/")
+        elif "invalid" in error_msg and "number" in error_msg:
+            print("\n   💡 Tip: Check phone number format. Should be E.164 format: +1234567890")
+        
+        return False
+
+
+def test_api_endpoint():
+    """Test the /api/sms/test endpoint."""
+    print("\n" + "=" * 60)
+    print("TESTING API ENDPOINT")
+    print("=" * 60)
+    
+    print("\nTo test via API, make a POST request:")
+    print('  curl -X POST http://localhost:8000/api/sms/test \\')
+    print('       -H "Content-Type: application/json" \\')
+    print('       -H "Authorization: Bearer <your_jwt_token>" \\')
+    print('       -d \'{"message": "Test message from API"}\'')
+
+
+if __name__ == "__main__":
+    print("\n" + "=" * 60)
+    print("LUMEA HEALTH - TWILIO SMS TEST SCRIPT")
+    print("=" * 60)
+    
+    success = test_twilio_sms()
+    test_api_endpoint()
+    
+    print("\n" + "=" * 60)
+    if success:
+        print("✅ All tests passed! Twilio is configured correctly.")
+    else:
+        print("❌ Some tests failed. Please check the configuration above.")
+    print("=" * 60 + "\n")
+    
+    sys.exit(0 if success else 1)

docker-compose.yml

@@ -28,12 +28,17 @@ services:
         BUILDKIT_INLINE_CACHE: 1
     container_name: ggw-backend
     restart: unless-stopped
+    # Load environment variables from root .env file
+    env_file:
+      - .env
     ports:
       - "8000:8000"
     # Ensures `host.docker.internal` works on Linux (needed for Ollama on host).
     extra_hosts:
       - "host.docker.internal:host-gateway"
     volumes:
+      # Mount .env file for configuration
+      - ./.env:/app/.env:ro
       # Mount source code for hot reload
       - ./backend/app:/app/app:cached
       # Mount Alembic migrations so schema fixes don't require rebuilding the image
@@ -79,6 +84,15 @@ services:
       - NEO4J_PASSWORD=${NEO4J_PASSWORD:-changeme}
       - MEM0_COLLECTION=${MEM0_COLLECTION:-user_memories}
       - GRAPHITI_DATABASE=${GRAPHITI_DATABASE:-neo4j}
+      # SMS Configuration (Twilio or mock mode)
+      - SMS_MODE=${SMS_MODE:-mock}
+      - SMS_TEST_TO_NUMBER=${SMS_TEST_TO_NUMBER:-}
+      - TWILIO_ACCOUNT_SID=${TWILIO_ACCOUNT_SID:-}
+      - TWILIO_AUTH_TOKEN=${TWILIO_AUTH_TOKEN:-}
+      - TWILIO_FROM_NUMBER=${TWILIO_FROM_NUMBER:-}
+      # Reminder Scheduler Configuration
+      - REMINDER_SCHEDULER_ENABLED=${REMINDER_SCHEDULER_ENABLED:-true}
+      - REMINDER_CHECK_INTERVAL_SECONDS=${REMINDER_CHECK_INTERVAL_SECONDS:-60}
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:8000/"]
       interval: 30s