Auto-sync backend and fix configuration

backend/api/routes/auth.py

@@ -0,0 +1,101 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from sqlalchemy.orm import Session
+
+from database import get_db
+import models.db_models as db_models
+import models.schemas as schemas
+import os
+
+# Configuration
+SECRET_KEY = os.getenv("JWT_SECRET_KEY", "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24 * 7 # 1 week
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login", auto_error=False)
+
+router = APIRouter(prefix="/auth", tags=["Authentication"])
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    if not token:
+        return None
+        
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = schemas.TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+        
+    user = db.query(db_models.User).filter(db_models.User.username == token_data.username).first()
+    if user is None:
+        raise credentials_exception
+    return user
+
+@router.post("/register", response_model=schemas.UserResponse)
+def register_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
+    db_user = db.query(db_models.User).filter(
+        (db_models.User.username == user.username) | (db_models.User.email == user.email)
+    ).first()
+    if db_user:
+        raise HTTPException(status_code=400, detail="Username or email already registered")
+    
+    hashed_password = get_password_hash(user.password)
+    db_user = db_models.User(
+        username=user.username,
+        email=user.email,
+        hashed_password=hashed_password
+    )
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+@router.post("/login", response_model=schemas.Token)
+def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
+    user = db.query(db_models.User).filter(db_models.User.username == form_data.username).first()
+    if not user or not verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user.username}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.get("/me", response_model=schemas.UserResponse)
+def read_users_me(current_user: db_models.User = Depends(get_current_user)):
+    if not current_user:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Not authenticated")
+    return current_user

backend/api/routes/history.py

@@ -1,17 +1,29 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Query
 from sqlalchemy.orm import Session
 from database import get_db
 import models.db_models as db_models
 import json
+from typing import Optional
+from api.routes.auth import get_current_user
 
 router = APIRouter(prefix="/history", tags=["History"])
 
 @router.get("")
-async def get_scan_history(limit: int = 50, db: Session = Depends(get_db)):
+async def get_scan_history(
+    limit: int = 50, 
+    scope: str = Query("global", description="Scope of history: 'global' or 'my'"),
+    db: Session = Depends(get_db),
+    current_user: Optional[db_models.User] = Depends(get_current_user)
+):
     """Retrieve the most recent scan records from the database."""
-    records = db.query(db_models.ScanRecord).order_by(
-        db_models.ScanRecord.timestamp.desc()
-    ).limit(limit).all()
+    query = db.query(db_models.ScanRecord)
+    
+    if scope == "my":
+        if not current_user:
+            return [] # Or raise 401
+        query = query.filter(db_models.ScanRecord.user_id == current_user.id)
+        
+    records = query.order_by(db_models.ScanRecord.timestamp.desc()).limit(limit).all()
     
     results = []
     for record in records:
@@ -24,6 +36,8 @@ async def get_scan_history(limit: int = 50, db: Session = Depends(get_db)):
             "threat_categories": json.loads(record.threat_categories) if record.threat_categories else [],
             "raw_text_extracted": record.raw_text_extracted,
             "behavioral_profile": json.loads(record.behavioral_profile) if getattr(record, "behavioral_profile", None) else None,
+            "source": getattr(record, "source", None),
+            "user_id": getattr(record, "user_id", None),
             "explanations": [
                 {
                     "feature": exp.feature,

backend/api/routes/scanner.py

@@ -5,13 +5,15 @@ from services.scam_detection import process_image, process_video, process_url, p
 from sqlalchemy.orm import Session
 from database import get_db
 import models.db_models as db_models
+from typing import Optional
+from api.routes.auth import get_current_user
 import json
 import asyncio
 from api.ws_manager import manager
 
 router = APIRouter(prefix="/scan", tags=["Scanner"])
 
-def save_scan_to_db(db: Session, result: ScanningResult):
+def save_scan_to_db(db: Session, result: ScanningResult, source: Optional[str] = None, user_id: Optional[int] = None):
     """Persist a ScanningResult into the SQLite database."""
     db_record = db_models.ScanRecord(
         id=result.id,
@@ -21,7 +23,9 @@ def save_scan_to_db(db: Session, result: ScanningResult):
         risk_level=result.risk_level,
         threat_categories=json.dumps(result.threat_categories),
         raw_text_extracted=result.raw_text_extracted,
-        behavioral_profile=json.dumps(result.behavioral_profile) if result.behavioral_profile else None
+        behavioral_profile=json.dumps(result.behavioral_profile) if result.behavioral_profile else None,
+        source=source,
+        user_id=user_id
     )
     
     for exp in result.explanations:
@@ -37,36 +41,68 @@ def save_scan_to_db(db: Session, result: ScanningResult):
     db.commit()
 
 @router.post("/image", response_model=ScanningResult)
-async def scan_image(file: UploadFile = File(...), ephemeral: str = Form("false"), db: Session = Depends(get_db)):
+async def scan_image(
+    file: UploadFile = File(...), 
+    ephemeral: str = Form("false"), 
+    source: Optional[str] = Form(None),
+    db: Session = Depends(get_db),
+    current_user: Optional[db_models.User] = Depends(get_current_user)
+):
     contents = await file.read()
     result = process_image(contents)
+    result.source = source
+    result.user_id = current_user.id if current_user else None
     if ephemeral.lower() != "true":
-        save_scan_to_db(db, result)
+        save_scan_to_db(db, result, source, current_user.id if current_user else None)
     broadcast_scan_result(result)
     return result
 
 @router.post("/video", response_model=ScanningResult)
-async def scan_video(file: UploadFile = File(...), ephemeral: str = Form("false"), db: Session = Depends(get_db)):
+async def scan_video(
+    file: UploadFile = File(...), 
+    ephemeral: str = Form("false"), 
+    source: Optional[str] = Form(None),
+    db: Session = Depends(get_db),
+    current_user: Optional[db_models.User] = Depends(get_current_user)
+):
     contents = await file.read()
     result = process_video(contents)
+    result.source = source
+    result.user_id = current_user.id if current_user else None
     if ephemeral.lower() != "true":
-        save_scan_to_db(db, result)
+        save_scan_to_db(db, result, source, current_user.id if current_user else None)
     broadcast_scan_result(result)
     return result
 
 @router.post("/url", response_model=ScanningResult)
-async def scan_url(url: str = Form(...), ephemeral: str = Form("false"), db: Session = Depends(get_db)):
+async def scan_url(
+    url: str = Form(...), 
+    ephemeral: str = Form("false"), 
+    source: Optional[str] = Form(None),
+    db: Session = Depends(get_db),
+    current_user: Optional[db_models.User] = Depends(get_current_user)
+):
     result = process_url(url)
+    result.source = source
+    result.user_id = current_user.id if current_user else None
     if ephemeral.lower() != "true":
-        save_scan_to_db(db, result)
+        save_scan_to_db(db, result, source, current_user.id if current_user else None)
     broadcast_scan_result(result)
     return result
 
 @router.post("/text", response_model=ScanningResult)
-async def scan_text(text: str = Form(...), ephemeral: str = Form("false"), db: Session = Depends(get_db)):
+async def scan_text(
+    text: str = Form(...), 
+    ephemeral: str = Form("false"), 
+    source: Optional[str] = Form(None),
+    db: Session = Depends(get_db),
+    current_user: Optional[db_models.User] = Depends(get_current_user)
+):
     result = process_text(text)
+    result.source = source
+    result.user_id = current_user.id if current_user else None
     if ephemeral.lower() != "true":
-        save_scan_to_db(db, result)
+        save_scan_to_db(db, result, source, current_user.id if current_user else None)
     broadcast_scan_result(result)
     return result
 
@@ -77,6 +113,9 @@ def broadcast_scan_result(result: ScanningResult):
         "risk_score": result.risk_score,
         "risk_level": result.risk_level,
         "threat_categories": result.threat_categories,
-        "timestamp": result.timestamp
+        "timestamp": result.timestamp,
+        "source": result.source
     }
+    
+    # Broadcast to all clients for real-time alerting
     asyncio.create_task(manager.broadcast(minimal_payload))

backend/main.py

@@ -4,6 +4,7 @@ from api.routes import scanner
 from api.routes import history
 from api.routes import stats
 from api.routes import export
+from api.routes import auth
 from api.ws_manager import manager
 import os
 
@@ -41,6 +42,7 @@ app.include_router(scanner.router, prefix="/api")
 app.include_router(history.router, prefix="/api")
 app.include_router(stats.router, prefix="/api")
 app.include_router(export.router, prefix="/api")
+app.include_router(auth.router, prefix="/api")
 
 # WebSocket endpoint — mounted directly on app to bypass CORS middleware
 @app.websocket("/ws/notifications")