Update web app, bouncer, and intelligence modules; add Chrome extension

Author: Anika438

app/index.html

@@ -5,7 +5,7 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Subway Scholars - Focus Run</title>
-    <link rel="stylesheet" href="/app/style.css">
+    <link rel="stylesheet" href="./style.css">
     <!-- Font Awesome for Icons -->
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
 </head>
@@ -130,7 +130,7 @@ <h2 class="notif-title"><i class="fa-solid fa-envelope-open-text"></i> Held Noti
         </div>
     </div>
 
-    <script src="/app/script.js"></script>
+    <script src="./script.js"></script>
 </body>
 
 </html>

bouncer/blocker_ui.py

@@ -20,8 +20,8 @@ def __init__(self, topic: str):
         self.root.title("Focus Blocker")
 
         # Make it 700x600 and center it
-        window_width = 700
-        window_height = 600
+        window_width = 750
+        window_height = 650
         screen_width = self.root.winfo_screenwidth()
         screen_height = self.root.winfo_screenheight()
         center_x = int(screen_width/2 - window_width / 2)
@@ -35,9 +35,9 @@ def __init__(self, topic: str):
         self.root.protocol("WM_DELETE_WINDOW", self.disable_event)
 
         # Fonts & Colors
-        self.title_font = ("Consolas", 32, "bold")
-        self.body_font = ("Arial", 16)
-        self.btn_font = ("Arial", 14, "bold")
+        self.title_font = ("Impact", 34, "normal")
+        self.body_font = ("Segoe UI", 16)
+        self.btn_font = ("Segoe UI", 14, "bold")
         self.color_danger = "#ff3b3b"
         self.color_primary = "#FF9800"
         self.color_bg = "#111827"
@@ -55,14 +55,19 @@ def build_ui_loading(self):
         """Displays a loading screen while Gemini generates the 3 questions."""
         self.clear_ui()
 
-        title_lbl = tk.Label(self.root, text="DISTRACTION DETECTED!", font=self.title_font, fg=self.color_danger, bg=self.color_bg)
-        title_lbl.pack(pady=(100, 20))
+        self.canvas = tk.Canvas(self.root, highlightthickness=0)
+        self.canvas.place(x=0, y=0, relwidth=1, relheight=1)
+        colors = ["#171e2e", "#131926"]
+        for i in range(30):
+            y = i * 30
+            self.canvas.create_rectangle(0, y, 1000, y+30, fill=colors[i%2], outline="")
+            
+        self.canvas.create_text(375, 150, text="DISTRACTION DETECTED!", font=self.title_font, fill=self.color_danger)
 
-        info_lbl = tk.Label(self.root, text=f"You must answer 3 questions about '{self.topic}' to unlock.", font=self.body_font, fg="#fff", bg=self.color_bg)
-        info_lbl.pack()
+        txt = f"You must answer 3 questions about '{self.topic}' to unlock."
+        self.canvas.create_text(375, 250, text=txt, font=self.body_font, fill="#fff", width=600, justify="center")
 
-        loading_lbl = tk.Label(self.root, text="Loading questions...", font=("Arial", 14), fg=self.color_primary, bg=self.color_bg)
-        loading_lbl.pack(pady=20)
+        self.canvas.create_text(375, 350, text="Loading questions...", font=("Segoe UI", 14), fill=self.color_primary)
 
     def fetch_questions(self):
         """Runs concurrently to fetch questions from Gemini."""
@@ -97,32 +102,30 @@ def build_ui_question(self):
 
         current_mcq = self.mcqs[self.current_q_index]
 
-        # Top Banner
-        header = tk.Frame(self.root, bg="#000", height=100)
-        header.pack(fill="x", side="top")
-        
-        title_lbl = tk.Label(header, text="FOCUS PENALTY", font=("Helvetica", 24, "bold"), fg=self.color_danger, bg="#000")
-        title_lbl.pack(pady=30)
+        self.canvas = tk.Canvas(self.root, highlightthickness=0)
+        self.canvas.place(x=0, y=0, relwidth=1, relheight=1)
+        colors = ["#171e2e", "#131926"]
+        for i in range(30):
+            y = i * 30
+            self.canvas.create_rectangle(0, y, 1000, y+30, fill=colors[i%2], outline="")
+            
+        # Top banner background
+        self.canvas.create_rectangle(0, 0, 1000, 80, fill="#0f172a", outline="")
+        self.canvas.create_text(375, 40, text="FOCUS PENALTY", font=("Impact", 28, "normal"), fill=self.color_primary)
 
-        progress_lbl = tk.Label(self.root, text=f"Question {self.current_q_index + 1} of {self.correct_answers_needed}", font=("Arial", 12, "bold"), fg=self.color_primary, bg=self.color_bg)
-        progress_lbl.pack(pady=20)
-
-        # Question Text
-        q_text = tk.Label(self.root, text=current_mcq.question, font=("Arial", 16), fg="#fff", bg=self.color_bg, wraplength=600, justify="center")
-        q_text.pack(pady=20)
-
-        # Container for evenly spaced buttons
-        btn_frame = tk.Frame(self.root, bg=self.color_bg)
-        btn_frame.pack(pady=20)
+        # Details & text
+        self.canvas.create_text(375, 120, text=f"Question {self.current_q_index + 1} of {self.correct_answers_needed}", font=("Segoe UI", 12, "bold"), fill=self.color_primary)
+        self.canvas.create_text(375, 180, text=current_mcq.question, font=("Segoe UI", 16), fill="#fff", width=650, justify="center")
 
-        # Create buttons
-        for opt in current_mcq.options:
+        # Buttons placed evenly
+        start_y = 280
+        for i, opt in enumerate(current_mcq.options):
             btn = tk.Button(
-                btn_frame, 
+                self.root, 
                 text=opt, 
-                font=("Arial", 11, "bold"), 
-                bg="#333", 
-                fg="#fff",
+                font=("Segoe UI", 12, "bold"), 
+                bg="#334155", 
+                fg="#f8fafc",
                 activebackground=self.color_primary,
                 activeforeground="#000",
                 width=50,
@@ -131,10 +134,9 @@ def build_ui_question(self):
                 cursor="hand2",
                 command=lambda o=opt: self.check_answer(o, current_mcq)
             )
-            btn.pack(pady=5)
+            self.canvas.create_window(375, start_y + (i * 65), window=btn)
 
-        self.feedback_lbl = tk.Label(self.root, text="", font=self.btn_font, bg=self.color_bg)
-        self.feedback_lbl.pack(pady=10)
+        self.feedback_text = self.canvas.create_text(375, 570, text="", font=self.btn_font, fill=self.color_danger, width=650, justify="center")
 
 
 
@@ -143,12 +145,12 @@ def check_answer(self, selected: str, mcq):
         if selected == mcq.correct_answer:
             self.current_q_index += 1
             if self.current_q_index >= self.correct_answers_needed:
-                self.feedback_lbl.config(text="Challenge Passed. Unlocking...", fg="#00E676")
+                self.canvas.itemconfig(self.feedback_text, text="Challenge Passed. Unlocking...", fill="#00E676")
                 self.root.after(1000, self.unlock_system)
             else:
                 self.build_ui_question()
         else:
-            self.feedback_lbl.config(text=f"WRONG! {mcq.explanation}", fg=self.color_danger, wraplength=800)
+            self.canvas.itemconfig(self.feedback_text, text=f"WRONG! {mcq.explanation}", fill=self.color_danger)
 
     def unlock_system(self):
         """Destroys the tkinter blocking window entirely."""

bouncer/main.py

@@ -110,6 +110,41 @@ async def lock_system(request: dict = None):
     print(f"System locked. Monitoring active for topic: {topic}", flush=True)
     return {"success": True, "message": "System locked. Monitoring resumed."}
 
+# --- Extension Integration Endpoints ---
+
+@app.get("/api/status")
+async def get_system_status():
+    """Returns basic state for the Chrome extension to display."""
+    if system_state["monitoring_active"] and not system_state["unlocked"]:
+         return {"active_sprint": {"suggested_topic": system_state["active_topic"]}}
+    return {"active_sprint": None}
+
+@app.get("/api/block")
+async def trigger_extension_block(url: str = None, topic: str = "General Study"):
+    """Triggers the Python tk popup window synchronously when called by the extension."""
+    if not system_state["is_blocking"]:
+         system_state["is_blocking"] = True
+         print(f"Browser distraction detected on {url}. Launching popup...", flush=True)
+         threading.Thread(
+            target=launch_os_blocker_sync,
+            args=(topic,),
+            daemon=True
+         ).start()
+    
+    # Return a simple HTML page telling the user they are blocked
+    html_content = f"""
+    <html>
+        <head><title>BLOCKED</title></head>
+        <body style="background-color: #111827; color: white; display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100vh; font-family: 'Segoe UI', sans-serif;">
+            <h1 style="color: #ff3b3b; font-size: 3rem;">FOCUS PENALTY</h1>
+            <p style="font-size: 1.5rem;">You tried to visit a distracting site during your '{topic}' sprint.</p>
+            <p>Please complete the challenge on your screen to proceed.</p>
+        </body>
+    </html>
+    """
+    from fastapi.responses import HTMLResponse
+    return HTMLResponse(content=html_content, status_code=200)
+
 # --- Brain Integration Endpoints ---
 
 class QuizRequest(BaseModel):
@@ -166,6 +201,18 @@ async def filter_notification_endpoint(request: NotificationRequest):
     is_relevant = intelligence.filter_notification(request.notification_text, request.current_topic)
     return {"is_relevant": is_relevant}
 
+class WindowRequest(BaseModel):
+    window_title: str
+    current_topic: str
+
+@app.post("/api/brain/filter_window")
+async def filter_window_endpoint(request: WindowRequest):
+    """Determines if a window/tab title is relevant to the topic."""
+    if not intelligence:
+         return {"is_relevant": False}
+    is_relevant = intelligence.is_window_relevant(request.window_title, request.current_topic)
+    return {"is_relevant": is_relevant}
+
 # --- Notification Monitor Endpoints ---
 
 @app.get("/api/notifications/held")
@@ -253,6 +300,9 @@ def distraction_monitor_loop():
     """Background thread that continuously scans active windows for blacklisted apps.
     Only runs when monitoring_active is True (after user clicks a sprint card)."""
     print("Distraction Monitor Thread Started.", flush=True)
+    pending_distraction_start = None
+    last_relevant_title = None
+
     while True:
         try:
             if system_state["monitoring_active"] and not system_state["unlocked"] and not system_state["is_blocking"]:
@@ -263,27 +313,52 @@ def distraction_monitor_loop():
                 if active_window is not None:
                     title = active_window.title.lower()
                     if any(app_name in title for app_name in BLACKLIST):
-                        print(f"Distraction detected: '{title}'. Notifying clients!", flush=True)
-                        system_state["is_blocking"] = True
-                        # Send BLOCK event to all connected UI clients
-                        import asyncio as _asyncio
-                        try:
-                            loop = _asyncio.get_event_loop()
-                            if loop.is_running():
-                                _asyncio.ensure_future(broadcast_event({
-                                    "event": "BLOCK",
-                                    "app": title,
-                                    "is_blocking": True,
-                                    "active_topic": system_state["active_topic"]
-                                }))
-                        except Exception as e:
-                            print(f"WS broadcast error: {e}", flush=True)
-                        # Also launch OS blocker as fallback
-                        threading.Thread(
-                            target=launch_os_blocker_sync,
-                            args=(system_state["active_topic"],),
-                            daemon=True
-                        ).start()
+                        if title == last_relevant_title:
+                            pass # Already approved this specific window/video
+                        elif pending_distraction_start is None:
+                            pending_distraction_start = time.time()
+                            print(f"Blacklisted app detected: '{title}'. Starting 15s grace period...", flush=True)
+                        elif time.time() - pending_distraction_start > 15:
+                            print(f"Grace period over. Checking relevance for: '{title}'...", flush=True)
+                            
+                            # AI Check for Window Relevance
+                            is_relevant = False
+                            if intelligence:
+                                try:
+                                    is_relevant = intelligence.is_window_relevant(title, system_state["active_topic"])
+                                except Exception as e:
+                                    print(f"Window relevance check failed: {e}", flush=True)
+                            
+                            if not is_relevant:
+                                print(f"Distraction confirmed: '{title}'. Notifying clients!", flush=True)
+                                system_state["is_blocking"] = True
+                                pending_distraction_start = None
+                                # Send BLOCK event to all connected UI clients
+                                import asyncio as _asyncio
+                                try:
+                                    loop = _asyncio.get_event_loop()
+                                    if loop.is_running():
+                                        _asyncio.ensure_future(broadcast_event({
+                                            "event": "BLOCK",
+                                            "app": title,
+                                            "is_blocking": True,
+                                            "active_topic": system_state["active_topic"]
+                                        }))
+                                except Exception as e:
+                                    print(f"WS broadcast error: {e}", flush=True)
+                                # Also launch OS blocker as fallback
+                                threading.Thread(
+                                    target=launch_os_blocker_sync,
+                                    args=(system_state["active_topic"],),
+                                    daemon=True
+                                ).start()
+                            else:
+                                print(f"Window '{title}' deemed relevant to topic '{system_state['active_topic']}'. Allowing.", flush=True)
+                                last_relevant_title = title
+                                pending_distraction_start = None
+                    else:
+                        pending_distraction_start = None
+                        # Don't reset last_relevant_title immediately if they tab out for a second
         except Exception as e:
             print(f"Monitor error: {e}", flush=True)
         time.sleep(1)