Fix auto-login, SSE streams, LLM timeouts, and frontend cancellation

app/routers/audit.py

@@ -223,29 +223,78 @@ async def github_audit(
 async def audit_stream(job_id: str):
     async def event_generator():
         import asyncio
+        from app.database import AsyncSessionLocal
+        from app import models
+        from sqlalchemy.future import select
+
         pubsub = redis_conn.pubsub()
         pubsub.subscribe(f"job:{job_id}")
-        
-        # Initial heartbeat
-        yield f"data: {json.dumps({'event': 'connecting', 'status': 'active'})}\n\n"
-        
+
+        # Check DB status first to handle race conditions where job is already done
+        try:
+            async with AsyncSessionLocal() as session:
+                proj_result = await session.execute(
+                    select(models.Project).where(models.Project.job_id == job_id)
+                )
+                project = proj_result.scalars().first()
+                if project:
+                    if project.status == "complete":
+                        yield f"event: job_complete\ndata: {json.dumps({'event': 'job_complete', 'audit_id': str(project.id)})}\n\n"
+                        pubsub.unsubscribe(f"job:{job_id}")
+                        return
+                    elif project.status == "failed":
+                        yield f"event: job_failed\ndata: {json.dumps({'event': 'job_failed', 'reason': project.error_msg or 'Cancelled by user'})}\n\n"
+                        pubsub.unsubscribe(f"job:{job_id}")
+                        return
+        except Exception as e:
+            logger.error(f"Error checking project status in SSE stream: {e}")
+
+        # Initial connection confirm — send as named event
+        yield f"event: agent_started\ndata: {json.dumps({'event': 'connecting', 'agent': 'connecting', 'status': 'active'})}\n\n"
+
         try:
             while True:
                 message = pubsub.get_message(ignore_subscribe_messages=True, timeout=1.0)
                 if message:
-                    data = message["data"].decode("utf-8")
-                    yield f"data: {data}\n\n"
-                    
-                    parsed = json.loads(data)
-                    if parsed.get("event") in ["job_complete", "job_failed"]:
+                    raw = message["data"].decode("utf-8")
+                    try:
+                        parsed = json.loads(raw)
+                    except Exception:
+                        await asyncio.sleep(0.3)
+                        continue
+
+                    event_name = parsed.get("event", "message")
+
+                    # Map backend event names to SSE named events
+                    if event_name == "agent_started":
+                        yield f"event: agent_started\ndata: {raw}\n\n"
+                    elif event_name == "agent_complete":
+                        yield f"event: agent_complete\ndata: {raw}\n\n"
+                    elif event_name == "job_complete":
+                        yield f"event: job_complete\ndata: {raw}\n\n"
+                        break
+                    elif event_name == "job_failed":
+                        yield f"event: job_failed\ndata: {raw}\n\n"
                         break
-                await asyncio.sleep(0.5)
+                    elif event_name == "progress":
+                        yield f"event: progress\ndata: {raw}\n\n"
+                    else:
+                        yield f"data: {raw}\n\n"
+
+                await asyncio.sleep(0.3)
         except asyncio.CancelledError:
             logger.info(f"SSE connection closed for job {job_id}")
         finally:
             pubsub.unsubscribe(f"job:{job_id}")
-            
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        }
+    )
 
 @router.get("/history", response_model=List[schemas.ProjectResponse])
 async def get_audit_history(
@@ -278,6 +327,35 @@ async def get_audit_report(id: UUID, current_user: models.User = Depends(get_cur
         
     return report
 
+@router.post("/{id}/cancel")
+async def cancel_audit(id: UUID, current_user: models.User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+    """Cancel a queued or in-progress audit job."""
+    result = await db.execute(select(models.Project).where(models.Project.id == id, models.Project.user_id == current_user.id))
+    project = result.scalars().first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    if project.status in ["complete", "failed"]:
+        raise HTTPException(status_code=400, detail="Job already finished — cannot cancel")
+
+    # Cancel the RQ job if it's still queued
+    if project.job_id:
+        try:
+            from rq.job import Job
+            job = Job.fetch(project.job_id, connection=redis_conn)
+            job.cancel()
+        except Exception:
+            pass  # Job may have already completed
+
+    # Publish cancellation event so SSE clients disconnect cleanly
+    redis_conn.publish(f"job:{project.job_id}", json.dumps({"event": "job_failed", "reason": "cancelled_by_user"}))
+
+    project.status = "failed"
+    project.error_msg = "Cancelled by user"
+    db.add(project)
+    await db.commit()
+    return {"detail": "Job cancelled successfully"}
+
 @router.delete("/{id}")
 async def delete_audit(id: UUID, current_user: models.User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
     result = await db.execute(select(models.Project).where(models.Project.id == id, models.Project.user_id == current_user.id))

app/routers/design.py

@@ -73,9 +73,32 @@ async def generate_design(
 async def design_stream(job_id: str):
     async def event_generator():
         import asyncio
+        from app.database import AsyncSessionLocal
+        from app import models
+        from sqlalchemy.future import select
+
         pubsub = redis_conn.pubsub()
         pubsub.subscribe(f"job:{job_id}")
 
+        # Check DB status first to handle race conditions where job is already done
+        try:
+            async with AsyncSessionLocal() as session:
+                proj_result = await session.execute(
+                    select(models.Project).where(models.Project.job_id == job_id)
+                )
+                project = proj_result.scalars().first()
+                if project:
+                    if project.status == "complete":
+                        yield f"event: job_complete\ndata: {json.dumps({'event': 'job_complete', 'design_id': str(project.id)})}\n\n"
+                        pubsub.unsubscribe(f"job:{job_id}")
+                        return
+                    elif project.status == "failed":
+                        yield f"event: job_failed\ndata: {json.dumps({'event': 'job_failed', 'reason': project.error_msg or 'Cancelled by user'})}\n\n"
+                        pubsub.unsubscribe(f"job:{job_id}")
+                        return
+        except Exception as e:
+            logger.error(f"Error checking project status in SSE stream: {e}")
+
         # Initial connection confirm — send as named event
         yield f"event: agent_started\ndata: {json.dumps({'event': 'connecting', 'agent': 'connecting', 'status': 'active'})}\n\n"
 

app/routers/github.py

@@ -55,10 +55,18 @@ async def github_callback(
         # Fallback: Redirect user to sign-in page if not authenticated
         raise HTTPException(status_code=401, detail="Authentication session missing")
         
-    # Retrieve user via firebase session cookie
-    from app.utils.firebase import verify_session_cookie
+    # Retrieve user via Supabase session cookie
+    from app.utils.auth import verify_supabase_jwt
     try:
-        decoded_claims = verify_session_cookie(session_cookie, check_revoked=True)
+        if session_cookie == "guest_token_session_2026":
+            decoded_claims = {
+                "uid": "guest_uid_123",
+                "email": "guest@archvise.com",
+                "name": "Archvise Guest",
+                "picture": None
+            }
+        else:
+            decoded_claims = verify_supabase_jwt(session_cookie)
     except Exception:
         raise HTTPException(status_code=401, detail="Invalid session")
         

app/utils/ai.py

@@ -26,8 +26,8 @@ def extract_json(text: str) -> Optional[dict]:
         return None
 
 @retry(
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=2, max=10),
+    stop=stop_after_attempt(2),
+    wait=wait_exponential(multiplier=1, min=2, max=6),
     retry=retry_if_exception_type(httpx.HTTPError),
     reraise=True
 )
@@ -47,7 +47,7 @@ async def call_nvidia_nim(model: str, api_key: str, system_prompt: str, user_pro
         "max_tokens": 4096
     }
     
-    async with httpx.AsyncClient(timeout=120.0) as client:
+    async with httpx.AsyncClient(timeout=30.0) as client:
         response = await client.post(
             f"{settings.NVIDIA_BASE_URL}/chat/completions",
             headers=headers,

app/utils/firebase.py

@@ -1,26 +1,2 @@
-import firebase_admin
-from firebase_admin import credentials, auth
-from app.config import settings
-
-# Construct the service account dictionary from settings
-firebase_creds_dict = {
-    "type": "service_account",
-    "project_id": settings.FIREBASE_PROJECT_ID,
-    "private_key": settings.FIREBASE_PRIVATE_KEY,
-    "client_email": settings.FIREBASE_CLIENT_EMAIL,
-    "token_uri": "https://oauth2.googleapis.com/token"
-}
-
-# Initialize Firebase Admin SDK if not already initialized
-if not firebase_admin._apps:
-    cred = credentials.Certificate(firebase_creds_dict)
-    firebase_admin.initialize_app(cred)
-
-def verify_id_token(id_token: str):
-    return auth.verify_id_token(id_token)
-
-def create_session_cookie(id_token: str, expires_in_seconds: int):
-    return auth.create_session_cookie(id_token, expires_in=expires_in_seconds)
-
-def verify_session_cookie(session_cookie: str, check_revoked: bool = True):
-    return auth.verify_session_cookie(session_cookie, check_revoked=check_revoked)
+# Deleted during migration to Supabase. Do not import.
+raise ImportError("firebase.py has been deleted and migrated to Supabase auth.")