import os import sys import asyncio import json import re import traceback import threading import warnings import logging import requests as http_requests from datetime import datetime from dotenv import load_dotenv from queue import Queue from functools import wraps # Suppress urllib3 SSL warnings (we use self-signed certs for local dev) warnings.filterwarnings("ignore", message="Unverified HTTPS request") from flask import Flask, Response, request, jsonify, send_from_directory, stream_with_context from flask_cors import CORS from flask_limiter import Limiter from flask_limiter.util import get_remote_address from werkzeug.middleware.proxy_fix import ProxyFix # Load environment variables load_dotenv(os.path.join(os.path.dirname(__file__), ".env")) load_dotenv(os.path.join(os.path.dirname(__file__), "mainAgent", ".env")) # ── Google ADK imports ───────────────────────────────────────────────── from google.adk.runners import Runner from google.adk.sessions import DatabaseSessionService from google.genai import types from mainAgent.agent import root_agent from mainAgent.sub_agents.prompt_wizard.agent import root_agent as prompt_wizard_agent # ── Database imports ─────────────────────────────────────────────────── from mainAgent.db.database import ( get_connection, release_connection, run_migrations ) # ── Flask App ────────────────────────────────────────────────────────── app = Flask(__name__, static_folder="frontend", static_url_path="") app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_prefix=1) CORS(app) # ── Rate Limiter (W-12 fix: prevent API credit abuse) ───────────────── # Uses in-memory storage (no Redis needed for a prototype). # Limits are per-user based on IP address. limiter = Limiter( get_remote_address, app=app, default_limits=["200 per minute"], # Global default for all endpoints storage_uri="memory://", # In-memory — suitable for single-process ) # ── Logging ──────────────────────────────────────────────────────────── logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", datefmt="%Y-%m-%d %H:%M:%S", ) logger = logging.getLogger("chatnct") # Disable caching for static files during development app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 @app.after_request def add_no_cache_headers(response): """Prevent browsers from caching JS/HTML files during development.""" if response.content_type and ('javascript' in response.content_type or 'html' in response.content_type): response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0' response.headers['Pragma'] = 'no-cache' return response # ── Custom API Request/Response Logging & Error Tracking ─────────────── @app.before_request def log_api_request(): if request.path.startswith("/api/"): method = request.method path = request.path ip = request.remote_addr payload = None if request.is_json: try: raw_payload = request.get_json() if isinstance(raw_payload, dict): payload = raw_payload.copy() if "password" in payload: payload["password"] = "********" # Mask large base64 image strings from face/QR verification for img_key in ["image", "photo", "frame", "face_image"]: if img_key in payload and isinstance(payload[img_key], str) and len(payload[img_key]) > 100: payload[img_key] = f"" else: payload = raw_payload except Exception: payload = "" logger.info(f"[REQ] {method} {path} | IP: {ip} | Payload: {payload}") @app.after_request def log_api_response(response): if request.path.startswith("/api/"): method = request.method path = request.path status = response.status_code logger.info(f"[RES] {method} {path} | Status: {status}") return response @app.errorhandler(Exception) def handle_exception(e): status_code = 500 if hasattr(e, "code"): status_code = e.code tb = traceback.format_exc() # Don't print massive tracebacks for standard 404 Not Found warnings if status_code == 404: logger.warning(f"[404] Not Found: {request.method} {request.path}") return jsonify({ "status": "error", "code": "NOT_FOUND", "message": f"The requested URL was not found: {request.path}" }), 404 # Log error message only (no traceback) logger.error(f"[ERROR] Exception on {request.method} {request.path}: {str(e)}") if hasattr(e, "code"): return jsonify({ "status": "error", "code": "SERVER_ERROR", "message": "A server error occurred." # VULN-03 FIX: Removed exception details from client response }), e.code return jsonify({ "status": "error", "code": "INTERNAL_SERVER_ERROR", "message": "An unexpected error occurred. Please try again later." # VULN-03 FIX: Removed exception details from client response }), 500 def is_greeting(message: str) -> bool: """Check if the user message is a simple greeting so we can respond instantly.""" msg = message.strip().lower() for char in [".", ",", "!", "?", "؟", "-", "_"]: msg = msg.replace(char, "") msg = msg.strip() greetings = { "hi", "hello", "hey", "اهلا", "أهلا", "أهلاً", "ازيك", "إزيك", "سلام", "سلام عليكم", "السلام عليكم", "صباح الخير", "مساء الخير", "منور", "يا فنان", "يا صديقي", "hi there", "hello there" } if msg in greetings: return True words = msg.split() if len(words) <= 3: for w in words: if w in greetings: return True return False # Suppress verbose request logs (GET /img/Logo.png, etc.) import logging log = logging.getLogger('werkzeug') log.setLevel(logging.ERROR) print("[STARTUP] Running database migrations...") try: run_migrations() print("[STARTUP] Database migrations checks passed.") except Exception as e: print(f"[STARTUP] Migration error (non-fatal): {e}") traceback.print_exc() # ── ADK Session Management ──────────────────────────────────────────── import uuid as _uuid APP_NAME = "chatnct" PROMPT_APP_NAME = "chatnct_prompt" # Retrieve Supabase database URL for ADK sessions. Fallback to sqlite if missing. db_url_env = os.getenv("DATABASE_URL") if db_url_env: if db_url_env.startswith("postgres://"): adk_db_url = db_url_env.replace("postgres://", "postgresql+asyncpg://", 1) elif db_url_env.startswith("postgresql://"): adk_db_url = db_url_env.replace("postgresql://", "postgresql+asyncpg://", 1) else: adk_db_url = db_url_env else: _SESSIONS_DB = os.path.join(os.path.dirname(__file__), "sessions.db") adk_db_url = f"sqlite+aiosqlite:///{_SESSIONS_DB}" print(f"[STARTUP] Initializing ADK Session Services & Runners (using DB URL schema: {adk_db_url.split('://')[0]})...") try: session_service = DatabaseSessionService(db_url=adk_db_url) runner = Runner( agent=root_agent, app_name=APP_NAME, session_service=session_service, ) print(f"[STARTUP] Main Agent ADK Runner ready (app: {APP_NAME})") except Exception as e: print(f"[STARTUP] Error initializing Main Agent ADK Runner: {e}") traceback.print_exc() try: prompt_session_service = DatabaseSessionService(db_url=adk_db_url) prompt_runner = Runner( agent=prompt_wizard_agent, app_name=PROMPT_APP_NAME, session_service=prompt_session_service, ) print(f"[STARTUP] Prompt Wizard ADK Runner ready (app: {PROMPT_APP_NAME})") except Exception as e: print(f"[STARTUP] Error initializing Prompt Wizard ADK Runner: {e}") traceback.print_exc() # Detect if running on Hugging Face Spaces (HF_SPACE is automatically set by Hugging Face) if os.getenv("HF_SPACE") or os.getenv("SPACE_ID"): _DEFAULT_ATTENDANCE_URL = "http://127.0.0.1:5001" else: _DEFAULT_ATTENDANCE_URL = "https://127.0.0.1:5001" ATTENDANCE_SERVER = os.getenv("ATTENDANCE_SERVER_URL", _DEFAULT_ATTENDANCE_URL) # ── Persistent Event Loop (Feature 9: Performance) ──────────────────── _loop = asyncio.new_event_loop() _loop_thread = threading.Thread(target=_loop.run_forever, daemon=True) _loop_thread.start() # Configurable timeout (W-08 fix): default 120s, override via AGENT_TIMEOUT env var _AGENT_TIMEOUT = int(os.getenv("AGENT_TIMEOUT", "120")) def run_async(coro, timeout=None): """Run an async coroutine on the persistent event loop. Uses a configurable timeout (default from AGENT_TIMEOUT env var). Logs a warning if the operation times out instead of silently hanging. """ if timeout is None: timeout = _AGENT_TIMEOUT future = asyncio.run_coroutine_threadsafe(coro, _loop) try: return future.result(timeout=timeout) except TimeoutError: future.cancel() logger.error("run_async timed out after %ds — cancelling coroutine", timeout) raise TimeoutError(f"Agent did not respond within {timeout}s. Please try again.") def _resolve_student_info(user_id: str) -> tuple: """Resolve (student_code, student_name, role) from profiles table given user_id.""" conn = get_connection() try: cur = conn.cursor() # 1. Check if user_id is already the student_code cur.execute("SELECT student_code, name, role FROM profiles WHERE student_code = %s", (user_id,)) row = cur.fetchone() if row: return str(row["student_code"]), str(row.get("name", "")), str(row.get("role", "student")) # 2. Check if user_id is the database UUID (id) cur.execute("SELECT student_code, name, role FROM profiles WHERE id::text = %s", (user_id,)) row = cur.fetchone() if row: return str(row["student_code"]), str(row.get("name", "")), str(row.get("role", "student")) return user_id, "", "student" except Exception: return user_id, "", "student" finally: release_connection(conn) _SEARCH_TRIGGER_PATTERNS = [ r"\bsearch\b", r"\bgoogle\b", r"\blookup\b", r"\blook up\b", r"\bfind\b", r"سيرش", r"سرش", r"سريش", r"ابحث", r"دور", r"دوّر", r"شوفلي", ] def _should_force_search(message: str) -> bool: """Return True when the user explicitly asks to search the web.""" text = (message or "").strip().lower() if not text: return False return any(re.search(pattern, text, re.IGNORECASE) for pattern in _SEARCH_TRIGGER_PATTERNS) # ── Code Generation Detection ───────────────────────────────────────── # Patterns that indicate the user pasted a code generation prompt # (typically from the Prompt Generator page). _CODE_PERSONA_PATTERN = re.compile( r"you are (?:a |an )?(?:senior|expert|professional|experienced|skilled|master)", re.IGNORECASE, ) _CODE_KEYWORD_PATTERNS = [ r"(?:build|create|develop|implement|write|code|generate|produce)\b.*\b(?:game|app|application|project|website|program|software|api|tool|script|bot)", r"Implementation Blueprint", r"Project Overview", r"Tech Stack", r"Folder Structure", r"Build Steps", r"requirements\.txt", r"```(?:python|javascript|typescript|bash|html|css|java|c\+\+|cpp|go|rust)", ] def _should_force_code(message: str) -> bool: """Return True when the message looks like a code-generation prompt. Detects two main patterns: 1. Expert persona prompt + coding keywords (from Prompt Generator) 2. Project blueprint / implementation plan with code blocks """ text = (message or "").strip() if not text: return False # Pattern 1: persona + coding keywords if _CODE_PERSONA_PATTERN.search(text): if any(re.search(kw, text, re.IGNORECASE) for kw in _CODE_KEYWORD_PATTERNS): return True # Pattern 2: multiple blueprint keywords present blueprint_hits = sum( 1 for kw in _CODE_KEYWORD_PATTERNS if re.search(kw, text, re.IGNORECASE) ) if blueprint_hits >= 3: return True return False import re def _build_contextual_message(user_id: str, message: str) -> str: # VULN-04 FIX: Sanitize message to prevent tag injection (e.g., [USER_ROLE: ...]) sanitized_message = re.sub(r'\[.*?\]', '', message) resolved_code, resolved_name, resolved_role = _resolve_student_info(user_id) prefixes = [f"[STUDENT_CODE: {resolved_code}]"] if resolved_name: prefixes.append(f"[STUDENT_NAME: {resolved_name}]") if resolved_role: prefixes.append(f"[USER_ROLE: {resolved_role}]") if _should_force_search(sanitized_message): prefixes.append("[FORCE_SEARCH: true]") if _should_force_code(sanitized_message): prefixes.append("[FORCE_CODE: true]") prefixes.append(sanitized_message) return "\n".join(prefixes) # ── Helper: Run agent ────────────────────────────────────────────────── async def _run_agent(user_id: str, message: str, chat_session_id: str = None) -> str: """Send a message to the root agent and collect the response. When *chat_session_id* is provided it is used as the ADK session_id so that each PostgreSQL chat session keeps its own isolated agent context. """ session_id = chat_session_id or str(_uuid.uuid4()) # Ensure a session object exists (idempotent – first call creates it) try: session_result = session_service.get_session( app_name=APP_NAME, user_id=user_id, session_id=session_id, ) import inspect if inspect.iscoroutine(session_result): session = await session_result else: session = session_result except Exception: session = None if session is None: session_result = session_service.create_session( app_name=APP_NAME, user_id=user_id, session_id=session_id, ) import inspect if inspect.iscoroutine(session_result): await session_result else: pass # already created synchronously contextual_message = _build_contextual_message(user_id, message) content = types.Content( role="user", parts=[types.Part.from_text(text=contextual_message)], ) response_parts = [] async for event in runner.run_async( user_id=user_id, session_id=session_id, new_message=content, ): if event.content and event.content.parts: for part in event.content.parts: if part.text: response_parts.append(part.text) return "\n".join(response_parts) if response_parts else "عذراً، مفيش رد متاح دلوقتي." # ── Direct Prompt Wizard (bypasses root agent) ───────────────────────── async def _run_prompt_wizard(user_id: str, idea: str) -> str: """Call the prompt_wizard agent directly — no root agent in the middle. Each invocation creates a fresh session (UUID) to prevent prompt history from leaking between different generation requests. """ session_id = str(_uuid.uuid4()) session_result = prompt_session_service.create_session( app_name=PROMPT_APP_NAME, user_id=user_id, session_id=session_id, ) import inspect if inspect.iscoroutine(session_result): await session_result # Send a clean, direct instruction to prompt_wizard prompt_message = f"Generate a professional master prompt for this idea: {idea}" content = types.Content( role="user", parts=[types.Part.from_text(text=prompt_message)], ) response_parts = [] async for event in prompt_runner.run_async( user_id=user_id, session_id=session_id, new_message=content, ): if event.content and event.content.parts: for part in event.content.parts: if part.text: response_parts.append(part.text) raw = "\n".join(response_parts) if response_parts else "" # ── Server-side cleanup: strip markdown code fences & conversational filler ── cleaned = raw.strip() # Remove ```markdown or ``` wrapper if present if cleaned.startswith("```"): first_newline = cleaned.find("\n") if first_newline != -1: cleaned = cleaned[first_newline + 1:] else: cleaned = cleaned[3:] if cleaned.endswith("```"): cleaned = cleaned[:-3] cleaned = cleaned.strip() # Remove any leading chatter lines before the actual prompt body # Patterns like "Here is your prompt:", "Sure! Here you go:", etc. chatter_patterns = [ r"^(?:here(?:'s| is| you go).*?[:!]?\s*\n)", r"^(?:sure[!,.]?\s*(?:here.*?)?[:!]?\s*\n)", r"^(?:of course[!,.]?\s*(?:here.*?)?[:!]?\s*\n)", r"^(?:absolutely[!,.]?\s*(?:here.*?)?[:!]?\s*\n)", r"^(?:اتفضل.*?\n)", r"^(?:تفضل.*?\n)", r"^(?:اهو.*?\n)", r"^(?:ده ال.*?prompt.*?\n)", ] for pattern in chatter_patterns: cleaned = re.sub(pattern, "", cleaned, count=1, flags=re.IGNORECASE) cleaned = cleaned.strip() # Remove any trailing chatter after the prompt trailing_patterns = [ r"\n(?:feel free|let me know|hope this helps|if you need|you can use).*$", r"\n(?:لو عايز|لو محتاج|ممكن تستخدم|تقدر تستخدم).*$", ] for pattern in trailing_patterns: cleaned = re.sub(pattern, "", cleaned, count=1, flags=re.IGNORECASE | re.DOTALL) cleaned = cleaned.strip() return cleaned if cleaned else raw.strip() async def _stream_agent(user_id: str, message: str, queue: Queue, chat_session_id: str = None) -> str: """Send agent text parts to a queue as they arrive. Uses *chat_session_id* (when provided) as the ADK session_id for context isolation — same strategy as _run_agent. """ session_id = chat_session_id or str(_uuid.uuid4()) # Ensure a session object exists try: session_result = session_service.get_session( app_name=APP_NAME, user_id=user_id, session_id=session_id, ) import inspect if inspect.iscoroutine(session_result): session = await session_result else: session = session_result except Exception: session = None if session is None: session_result = session_service.create_session( app_name=APP_NAME, user_id=user_id, session_id=session_id, ) import inspect if inspect.iscoroutine(session_result): await session_result contextual_message = _build_contextual_message(user_id, message) content = types.Content( role="user", parts=[types.Part.from_text(text=contextual_message)], ) response_parts = [] async for event in runner.run_async( user_id=user_id, session_id=session_id, new_message=content, ): if event.content and event.content.parts: for part in event.content.parts: # Check for tool/function calls to update the waiting status dynamically try: if hasattr(part, "function_call") and part.function_call: name = part.function_call.name args = part.function_call.args args_dict = {} if args: try: args_dict = dict(args) except Exception: if hasattr(args, "items"): args_dict = {k: v for k, v in args.items()} status_msg = None if name == "search_material": q = args_dict.get("query", "") status_msg = f"Searching lectures for '{q}'" if q else "Searching lecture files" elif name == "get_all_materials_info": status_msg = "Reviewing available lectures list" elif name == "get_available_subjects": status_msg = "Checking available subjects" elif name == "generate_project_blueprint": req = args_dict.get("requirement", "") short_req = (req[:30] + "...") if req and len(req) > 30 else req status_msg = f"Planning blueprint for '{short_req}'" if req else "Planning project blueprint" elif name == "generate_code_files": req = args_dict.get("requirement", "") short_req = (req[:30] + "...") if req and len(req) > 30 else req status_msg = f"Generating code for '{short_req}'" if req else "Writing code files" elif name == "debug_code_issue": err = args_dict.get("error_message", "") short_err = (err[:30] + "...") if err and len(err) > 30 else err status_msg = f"Debugging code issue '{short_err}'" if err else "Analyzing code for bugs" elif name == "search_data": q = args_dict.get("query", "") short_q = (q[:35] + "...") if q and len(q) > 35 else q status_msg = f"Searching university rules for '{short_q}'" if q else "Checking student affairs rules" elif name == "duckduckgo_search_tool": q = args_dict.get("query", "") short_q = (q[:35] + "...") if q and len(q) > 35 else q status_msg = f"Searching the web for '{short_q}'" if q else "Searching the web" elif name == "get_student_attendance_summary": status_msg = "Calculating attendance & absences summary" elif name == "get_course_session_log": course = args_dict.get("course_code_or_name", "") status_msg = f"Reviewing attendance log for {course}" if course else "Reviewing attendance logs" elif name == "get_missed_lectures": status_msg = "Checking missed lectures list" elif name == "get_missed_lecture_summaries": status_msg = "Generating missed lecture summaries" elif name == "transfer_to_agent": target = args_dict.get("agent_name", args_dict.get("target_agent_name", "")) status_msg = f"Routing request to {target}" if target else "Routing request" elif name == "study_agent": status_msg = "Accessing study assistant" elif name == "vibe_coder_agent": status_msg = "Opening code builder" elif name == "search_agent": status_msg = "Accessing web search tools" elif name == "student_chatbot": status_msg = "Accessing student affairs" elif name == "academic_analyzer": status_msg = "Analyzing academic records" elif name == "prompt_wizard": status_msg = "Opening Prompt Wizard" if status_msg: queue.put({"type": "status", "status": status_msg}) except Exception: pass if part.text: response_parts.append(part.text) queue.put({"type": "delta", "text": part.text}) return "\n".join(response_parts) if response_parts else "عذرًا، مفيش رد متاح دلوقتي." # HELPERS # ══════════════════════════════════════════════════════════════════════ def _resolve_student_uuid(user_id: str) -> str: """Look up a student's UUID from their student_code in the profiles table. Returns None if not found.""" conn = get_connection() try: cur = conn.cursor() cur.execute("SELECT id FROM profiles WHERE student_code = %s", (user_id,)) row = cur.fetchone() if row: return str(row["id"]) return None finally: release_connection(conn) # ══════════════════════════════════════════════════════════════════════ def _create_chat_session(user_id: str, message: str) -> str: conn = get_connection() try: cur = conn.cursor() title = message[:50] + ("..." if len(message) > 50 else "") cur.execute( "INSERT INTO chat_sessions (student_id, title) VALUES (%s, %s) RETURNING id", (user_id, title) ) chat_session_id = str(cur.fetchone()[0]) conn.commit() return chat_session_id finally: release_connection(conn) def _save_chat_message(chat_session_id: str, role: str, content: str) -> None: conn = get_connection() try: cur = conn.cursor() cur.execute( "INSERT INTO chat_messages (session_id, role, content) VALUES (%s, %s, %s)", (chat_session_id, role, content) ) conn.commit() finally: release_connection(conn) # ── Auth Decorator ───────────────────────────────────────────────────── def token_required(f): """Validate Supabase JWT from 'Authorization: Bearer ' header. Injects `current_user_id` (the verified Supabase UUID) into route kwargs. Returns 401 if the token is missing or invalid, 500 on auth-service failure. """ @wraps(f) def decorated(*args, **kwargs): auth_header = request.headers.get("Authorization", "") if not auth_header.startswith("Bearer "): logger.warning("[AUTH] Access denied: Missing or invalid 'Bearer' prefix in Authorization header.") return jsonify({ "status": "error", "code": "MISSING_TOKEN", "message": "Authorization token is required.", }), 401 token = auth_header.split(" ", 1)[1].strip() if not token: logger.warning("[AUTH] Access denied: Authorization token is empty after Bearer prefix.") return jsonify({ "status": "error", "code": "MISSING_TOKEN", "message": "Authorization token is required.", }), 401 supabase_url = os.getenv("SUPABASE_URL") supabase_key = os.getenv("SUPABASE_ANON_KEY") or os.getenv("SUPABASE_SERVICE_ROLE_KEY") try: res = http_requests.get( f"{supabase_url}/auth/v1/user", headers={ "apikey": supabase_key, "Authorization": f"Bearer {token}", }, timeout=10, ) if res.status_code != 200: logger.warning(f"[AUTH] Access denied: Supabase auth validation failed with status {res.status_code}. Response: {res.text.strip()}") return jsonify({ "status": "error", "code": "INVALID_TOKEN", "message": "Invalid or expired token. Please log in again.", }), 401 user_data = res.json() current_user_id = user_data.get("id") if not current_user_id: logger.warning("[AUTH] Access denied: User ID missing from Supabase user payload.") return jsonify({ "status": "error", "code": "INVALID_TOKEN", "message": "Could not extract user identity from token.", }), 401 except Exception as e: logger.error(f"[AUTH] Auth service exception: {str(e)}", exc_info=True) return jsonify({ "status": "error", "code": "AUTH_SERVICE_ERROR", "message": f"Auth service error: {str(e)}", }), 500 # Inject the verified UUID into the route — never trust client-provided IDs kwargs["current_user_id"] = current_user_id return f(*args, **kwargs) return decorated def _verify_session_ownership(session_id: str, user_uuid: str) -> bool: """Return True if the chat session belongs to the authenticated user. Checks both the raw Supabase UUID and the associated student_code to handle sessions that may have been created before the auth decorator was enforced. """ conn = get_connection() try: cur = conn.cursor() # Resolve the student_code linked to this UUID cur.execute( "SELECT student_code FROM profiles WHERE id::text = %s", (user_uuid,), ) row = cur.fetchone() student_code = str(row["student_code"]) if row and row.get("student_code") else None if student_code: cur.execute( "SELECT 1 FROM chat_sessions" " WHERE id = %s AND (student_id = %s OR student_id = %s)", (session_id, user_uuid, student_code), ) else: cur.execute( "SELECT 1 FROM chat_sessions WHERE id = %s AND student_id = %s", (session_id, user_uuid), ) return cur.fetchone() is not None except Exception: return False finally: release_connection(conn) def instructor_required(f): """Ensure the user is an instructor or admin.""" @wraps(f) def decorated(*args, **kwargs): current_user_id = kwargs.get("current_user_id") if not current_user_id: return jsonify({"status": "error", "code": "UNAUTHORIZED", "message": "User identity missing."}), 401 conn = get_connection() try: cur = conn.cursor() cur.execute("SELECT role FROM profiles WHERE id::text = %s", (current_user_id,)) row = cur.fetchone() if not row or row["role"] not in ("instructor", "admin"): return jsonify({"status": "error", "code": "FORBIDDEN", "message": "Instructor privileges required."}), 403 finally: release_connection(conn) return f(*args, **kwargs) return decorated # API ENDPOINTS # ══════════════════════════════════════════════════════════════════════ # ── Chat (with Supabase persistence — Feature 1) ────────────────────── @app.route("/api/chat", methods=["POST"]) @limiter.limit("20 per minute") # W-12: rate limit chat to prevent credit abuse @token_required def chat(current_user_id: str): """Send a message to the root agent and return the response. Saves to DB.""" data = request.get_json() message = data.get("message", "").strip() chat_session_id = data.get("session_id", None) # Supabase chat_sessions.id if not message: return jsonify({"status": "error", "code": "MISSING_MESSAGE", "message": "Message is required."}), 400 try: # Create a new session, or verify ownership of an existing one (IDOR fix) if not chat_session_id: chat_session_id = _create_chat_session(current_user_id, message) elif not _verify_session_ownership(chat_session_id, current_user_id): return jsonify({"status": "error", "code": "FORBIDDEN", "message": "Access denied to this session."}), 403 # Save user message _save_chat_message(chat_session_id, "user", message) # Check for instant greeting response if is_greeting(message): resolved_code, resolved_name, resolved_role = _resolve_student_info(current_user_id) if resolved_role in ("instructor", "admin"): response = f"أهلاً بحضرتك يا دكتور {resolved_name if resolved_name else ''}. كيف يمكنني مساعدة سيادتك اليوم؟" else: response = "أهلاً يا فنان! منور ChatNCT. أقدر أساعدك إزاي النهاردة في المنهج أو أي حاجة تانية؟" _save_chat_message(chat_session_id, "bot", response) return jsonify({ "status": "success", "response": response, "session_id": chat_session_id, }) # Get agent response (UUID passed; _build_contextual_message resolves student_code) response = run_async(_run_agent(current_user_id, message, chat_session_id=chat_session_id)) # Save bot response _save_chat_message(chat_session_id, "bot", response) return jsonify({ "status": "success", "response": response, "session_id": chat_session_id, }) except Exception as e: traceback.print_exc() return jsonify({ "status": "error", "code": "AGENT_ERROR", "message": f"Agent error: {str(e)}", "traceback": traceback.format_exc() }), 500 # ── Feature 1: Chat Sessions CRUD ───────────────────────────────────── @app.route("/api/chat/stream", methods=["POST"]) @limiter.limit("20 per minute") # W-12: rate limit streaming chat @token_required def chat_stream(current_user_id: str): """Stream agent text parts as newline-delimited JSON for a faster chat feel.""" data = request.get_json() message = data.get("message", "").strip() chat_session_id = data.get("session_id", None) if not message: return jsonify({"status": "error", "code": "MISSING_MESSAGE", "message": "Message is required."}), 400 try: # Create a new session, or verify ownership of an existing one (IDOR fix) if not chat_session_id: chat_session_id = _create_chat_session(current_user_id, message) elif not _verify_session_ownership(chat_session_id, current_user_id): return jsonify({"status": "error", "code": "FORBIDDEN", "message": "Access denied to this session."}), 403 _save_chat_message(chat_session_id, "user", message) except Exception as e: traceback.print_exc() return jsonify({ "status": "error", "code": "DB_ERROR", "message": f"Database error: {str(e)}", }), 500 def encode_event(payload): return json.dumps(payload, ensure_ascii=False) + "\n" @stream_with_context def generate(): queue = Queue() yield encode_event({"type": "meta", "session_id": chat_session_id}) if is_greeting(message): resolved_code, resolved_name, resolved_role = _resolve_student_info(current_user_id) if resolved_role in ("instructor", "admin"): response_text = f"أهلاً بحضرتك يا دكتور {resolved_name if resolved_name else ''}. كيف يمكنني مساعدة سيادتك اليوم؟" else: response_text = "أهلاً يا فنان! منور ChatNCT. أقدر أساعدك إزاي النهاردة في المنهج أو أي حاجة تانية؟" yield encode_event({"type": "delta", "text": response_text}) _save_chat_message(chat_session_id, "bot", response_text) yield encode_event({"type": "done"}) return async def run_and_finish(): try: response_text = await _stream_agent(current_user_id, message, queue, chat_session_id=chat_session_id) if not response_text: response_text = "عذرًا، مفيش رد متاح دلوقتي." _save_chat_message(chat_session_id, "bot", response_text) queue.put({"type": "done"}) except Exception as exc: traceback.print_exc() queue.put({"type": "error", "message": f"Agent error: {str(exc)}"}) future = asyncio.run_coroutine_threadsafe(run_and_finish(), _loop) try: while True: item = queue.get() yield encode_event(item) if item.get("type") in {"done", "error"}: break finally: if not future.done(): future.cancel() return Response( generate(), mimetype="application/x-ndjson", headers={ "Cache-Control": "no-cache", "X-Accel-Buffering": "no", }, ) @app.route("/api/chat/sessions", methods=["GET"]) @token_required def list_chat_sessions(current_user_id: str): """List chat sessions for the authenticated user with pagination.""" page = max(1, int(request.args.get("page", 1))) # VULN-10 FIX: Cap per_page to a maximum of 50 to prevent DoS per_page = min(max(1, int(request.args.get("per_page", 20))), 50) offset = (page - 1) * per_page conn = get_connection() try: cur = conn.cursor() # Resolve the student_code so sessions stored under either identifier are found cur.execute( "SELECT student_code FROM profiles WHERE id::text = %s", (current_user_id,), ) row = cur.fetchone() student_code = str(row["student_code"]) if row and row.get("student_code") else None if student_code: cur.execute( "SELECT COUNT(*) FROM chat_sessions" " WHERE student_id = %s OR student_id = %s", (current_user_id, student_code), ) total = cur.fetchone()[0] cur.execute(""" SELECT id, title, created_at FROM chat_sessions WHERE student_id = %s OR student_id = %s ORDER BY created_at DESC LIMIT %s OFFSET %s """, (current_user_id, student_code, per_page, offset)) else: cur.execute( "SELECT COUNT(*) FROM chat_sessions WHERE student_id = %s", (current_user_id,), ) total = cur.fetchone()[0] cur.execute(""" SELECT id, title, created_at FROM chat_sessions WHERE student_id = %s ORDER BY created_at DESC LIMIT %s OFFSET %s """, (current_user_id, per_page, offset)) sessions = [] for row in cur.fetchall(): r = dict(row) r["id"] = str(r["id"]) r["created_at"] = str(r["created_at"]) sessions.append(r) return jsonify({ "status": "success", "sessions": sessions, "total": total, "page": page, "per_page": per_page, }) finally: release_connection(conn) @app.route("/api/chat/sessions//messages", methods=["GET"]) @token_required def get_chat_messages(session_id, current_user_id: str): """Get messages for a chat session with pagination (ownership enforced).""" if not _verify_session_ownership(session_id, current_user_id): return jsonify({"status": "error", "code": "FORBIDDEN", "message": "Access denied to this session."}), 403 page = int(request.args.get("page", 1)) per_page = int(request.args.get("per_page", 50)) offset = (page - 1) * per_page conn = get_connection() try: cur = conn.cursor() cur.execute("SELECT COUNT(*) FROM chat_messages WHERE session_id = %s", (session_id,)) total = cur.fetchone()[0] cur.execute(""" SELECT id, role, content, created_at FROM chat_messages WHERE session_id = %s ORDER BY created_at ASC LIMIT %s OFFSET %s """, (session_id, per_page, offset)) messages = [] for row in cur.fetchall(): r = dict(row) r["id"] = str(r["id"]) r["created_at"] = str(r["created_at"]) messages.append(r) return jsonify({ "status": "success", "messages": messages, "total": total, "page": page, "per_page": per_page, }) finally: release_connection(conn) @app.route("/api/chat/sessions/", methods=["DELETE"]) @token_required def delete_chat_session(session_id, current_user_id: str): """Delete a chat session and all its messages (ownership enforced).""" if not _verify_session_ownership(session_id, current_user_id): return jsonify({"status": "error", "code": "FORBIDDEN", "message": "Access denied to this session."}), 403 conn = get_connection() try: cur = conn.cursor() cur.execute("DELETE FROM chat_sessions WHERE id = %s", (session_id,)) affected = cur.rowcount conn.commit() if affected == 0: return jsonify({"status": "error", "code": "SESSION_NOT_FOUND", "message": "Session not found."}), 404 return jsonify({"status": "success", "message": "Session deleted."}) finally: release_connection(conn) @app.route("/api/chat/sessions//rename", methods=["PUT"]) @token_required def rename_chat_session(session_id, current_user_id: str): """Rename a chat session (ownership enforced).""" if not _verify_session_ownership(session_id, current_user_id): return jsonify({"status": "error", "code": "FORBIDDEN", "message": "Access denied to this session."}), 403 data = request.get_json() title = data.get("title", "").strip() if not title: return jsonify({"status": "error", "code": "MISSING_TITLE", "message": "Title is required."}), 400 conn = get_connection() try: cur = conn.cursor() cur.execute("UPDATE chat_sessions SET title = %s WHERE id = %s", (title, session_id)) affected = cur.rowcount conn.commit() if affected == 0: return jsonify({"status": "error", "code": "SESSION_NOT_FOUND", "message": "Session not found."}), 404 return jsonify({"status": "success", "message": "Session renamed."}) finally: release_connection(conn) # ── Prompt Generation ───────────────────────────────────────────────── @app.route("/api/prompt/generate", methods=["POST"]) @limiter.limit("10 per minute") # W-12: rate limit prompt generation @token_required def generate_prompt(current_user_id: str): data = request.get_json() idea = data.get("idea", "").strip() user_id = current_user_id if not idea: return jsonify({"status": "error", "message": "Idea is required."}), 400 try: # Call prompt_wizard DIRECTLY — bypasses the root agent entirely response = run_async(_run_prompt_wizard(user_id, idea)) return jsonify({"status": "success", "prompt": response}) except Exception as e: traceback.print_exc() return jsonify({"status": "error", "message": f"Agent error: {str(e)}"}), 500 # ── Code Generation (Vibe Coder) ────────────────────────────────────── @app.route("/api/code/generate", methods=["POST"]) @limiter.limit("10 per minute") # W-12: rate limit code generation @token_required def generate_code(current_user_id: str): data = request.get_json() prompt = data.get("prompt", "").strip() # Use authenticated user ID instead of accepting it from the payload user_id = current_user_id if not prompt: return jsonify({"status": "error", "message": "Prompt is required."}), 400 try: code_message = f"اكتبلي كود: {prompt}" response = run_async(_run_agent(user_id, code_message)) return jsonify({"status": "success", "code": response}) except Exception as e: traceback.print_exc() return jsonify({"status": "error", "message": f"Agent error: {str(e)}"}), 500 # ── Auth (Supabase Auth — server-side validation) ───────────────────── @app.route("/api/auth/login", methods=["POST"]) @limiter.limit("5 per minute") # VULN-05 FIX: Rate limit login attempts def login(): """Validate user credentials via Supabase Auth and return profile info.""" data = request.get_json() email = data.get("email", "").strip() password = data.get("password", "") if not email or not password: return jsonify({"status": "error", "message": "Email and password required."}), 400 # Authenticate via Supabase Auth supabase_url = os.getenv("SUPABASE_URL") supabase_key = os.getenv("SUPABASE_ANON_KEY") try: auth_res = http_requests.post( f"{supabase_url}/auth/v1/token?grant_type=password", headers={ "apikey": supabase_key, "Content-Type": "application/json", }, json={"email": email, "password": password}, timeout=10, ) auth_data = auth_res.json() if auth_res.status_code != 200: error_msg = auth_data.get("error_description") or auth_data.get("msg") or "Invalid credentials." return jsonify({"status": "error", "message": error_msg}), 401 access_token = auth_data.get("access_token", "") refresh_token = auth_data.get("refresh_token", "") user_id = auth_data.get("user", {}).get("id", "") except Exception as e: return jsonify({"status": "error", "message": f"Auth service error: {str(e)}"}), 500 # Fetch profile from unified profiles table conn = get_connection() try: cur = conn.cursor() cur.execute( "SELECT id, name, role, status, student_code FROM profiles WHERE id = %s", (user_id,) ) row = cur.fetchone() if not row: return jsonify({"status": "error", "message": "Profile not found."}), 404 profile = dict(row) role = profile["role"] display_name = profile["name"] student_code = profile.get("student_code", "") finally: release_connection(conn) return jsonify({ "status": "success", "is_admin": role in ("instructor", "admin"), "username": display_name, "role": role, "access_token": access_token, "refresh_token": refresh_token, "user_id": student_code or str(user_id), }) # ══════════════════════════════════════════════════════════════════════ # ATTENDANCE SERVER PROXY # ══════════════════════════════════════════════════════════════════════ @app.route("/api/courses", methods=["GET"]) @token_required def get_courses(current_user_id: str): conn = get_connection() try: cur = conn.cursor() cur.execute(""" SELECT c.id AS course_id, c.course_code, c.name AS course_name, c.instructor_id, p.name AS instructor_name FROM courses c LEFT JOIN profiles p ON c.instructor_id = p.id ORDER BY c.course_code """) rows = [dict(r) for r in cur.fetchall()] return jsonify(rows) except Exception as e: return jsonify({"status": "error", "message": str(e)}), 500 finally: release_connection(conn) @app.route("/api/session/create", methods=["POST"]) @token_required @instructor_required def proxy_create_session(current_user_id: str): """Proxy to attendance server with retry (server may still be loading models on first call).""" import time as _time last_err = None for attempt in range(3): try: r = http_requests.post( f"{ATTENDANCE_SERVER}/api/session/create", json=request.get_json(), verify=False, timeout=20, ) return jsonify(r.json()), r.status_code except Exception as e: last_err = e if attempt < 2: _time.sleep(5) # wait 5s then retry return jsonify({"status": "error", "message": "The Attendance AI model is still loading in the background. Please wait 1-2 minutes and try again."}), 502 @app.route("/api/session/", methods=["GET"]) @token_required def proxy_check_session(code, current_user_id: str): try: r = http_requests.get(f"{ATTENDANCE_SERVER}/api/session/{code}", verify=False, timeout=15) return jsonify(r.json()), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Attendance server unreachable: {e}"}), 502 @app.route("/api/session//qr-token", methods=["GET"]) @token_required @instructor_required def proxy_qr_token(code, current_user_id: str): """Proxy: get rotating QR token.""" try: r = http_requests.get(f"{ATTENDANCE_SERVER}/api/session/{code}/qr-token", verify=False, timeout=15) return jsonify(r.json()), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Attendance server unreachable: {e}"}), 502 @app.route("/api/attendance/verify", methods=["POST"]) @token_required def proxy_verify_attendance(current_user_id: str): try: r = http_requests.post( f"{ATTENDANCE_SERVER}/api/attendance/verify", json=request.get_json(), verify=False, timeout=120, ) return jsonify(r.json()), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Attendance server unreachable: {e}"}), 502 @app.route("/api/attendance/check_identity", methods=["POST"]) @token_required def proxy_check_identity(current_user_id: str): try: r = http_requests.post( f"{ATTENDANCE_SERVER}/api/attendance/check_identity", json=request.get_json(), verify=False, timeout=120, ) resp_data = r.json() return jsonify(resp_data), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Server unreachable: {e}"}), 502 @app.route("/api/attendance/check_pose", methods=["POST"]) @token_required def proxy_check_pose(current_user_id: str): try: r = http_requests.post( f"{ATTENDANCE_SERVER}/api/attendance/check_pose", json=request.get_json(), verify=False, timeout=10, ) resp_data = r.json() return jsonify(resp_data), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Server unreachable: {e}"}), 502 @app.route("/api/attendance/challenges", methods=["GET"]) @token_required def proxy_challenges(current_user_id: str): """Proxy: get liveness challenges.""" try: r = http_requests.get(f"{ATTENDANCE_SERVER}/api/attendance/challenges", verify=False, timeout=15) return jsonify(r.json()), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Attendance server unreachable: {e}"}), 502 @app.route("/api/attendance/prepare", methods=["POST"]) @token_required def proxy_prepare(current_user_id: str): """Proxy: pre-cache student embedding for fast identity check.""" try: r = http_requests.post( f"{ATTENDANCE_SERVER}/api/attendance/prepare", json=request.get_json(), verify=False, timeout=30, ) return jsonify(r.json()), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Attendance server unreachable: {e}"}), 502 @app.route("/api/session//report", methods=["GET"]) @token_required @instructor_required def proxy_session_report(code, current_user_id: str): try: r = http_requests.get(f"{ATTENDANCE_SERVER}/api/session/{code}/report", verify=False, timeout=15) return jsonify(r.json()), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Attendance server unreachable: {e}"}), 502 @app.route("/api/session//close", methods=["POST"]) @token_required @instructor_required def proxy_close_session(code, current_user_id: str): try: r = http_requests.post(f"{ATTENDANCE_SERVER}/api/session/{code}/close", verify=False, timeout=15) return jsonify(r.json()), r.status_code except Exception as e: return jsonify({"status": "error", "message": f"Attendance server unreachable: {e}"}), 502 # ══════════════════════════════════════════════════════════════════════ # FRONTEND SERVING # ══════════════════════════════════════════════════════════════════════ @app.route("/") def serve_index(): return send_from_directory("frontend", "index.html") @app.route("/") def serve_static(path): return send_from_directory("frontend", path) # ══════════════════════════════════════════════════════════════════════ # MAIN # ══════════════════════════════════════════════════════════════════════ if __name__ == "__main__": import ssl import socket def get_lan_ip(): try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(("8.8.8.8", 80)) ip = s.getsockname()[0] s.close() return ip except Exception: return "127.0.0.1" try: from mainAgent.web.generate_cert import generate_self_signed_cert cert_dir = os.path.dirname(__file__) cert_path, key_path = generate_self_signed_cert(cert_dir) ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) ssl_ctx.load_cert_chain(cert_path, key_path) except Exception as e: print(f"Warning: Could not generate SSL certs. Falling back to HTTP. {e}") ssl_ctx = None lan_ip = get_lan_ip() protocol = "https" if ssl_ctx else "http" print(f"Local URL: {protocol}://localhost:5000/") print(f"Network URL: {protocol}://{lan_ip}:5000/") print("[INFO] Serving frontend and API requests...") print("[INFO] Press Ctrl+C in this terminal to stop the server.") try: app.run(host="0.0.0.0", port=5000, use_reloader=False, ssl_context=ssl_ctx) except OSError as os_err: print(f"[CRITICAL] OSError starting server: {os_err}") if "address already in use" in str(os_err).lower() or os_err.errno in (98, 10048): print("[CRITICAL] PORT 5000 IS ALREADY OCCUPIED!") print("Another process is running on this port. To fix this:") print("- Run 'Stop-Process -Name python -Force' in PowerShell") print("- Or run 'taskkill /IM python.exe /F' in CMD") print("Then try starting this server again.") else: traceback.print_exc() except Exception as e: print(f"[CRITICAL] Exception starting server: {e}") traceback.print_exc()