1#!/usr/bin/env python3
2"""
3Browser Session Management for NotebookLM
4Individual browser session for persistent NotebookLM conversations
5Based on the original NotebookLM API implementation
6"""
7 
8import time
9import sys
10from typing import Any, Dict, Optional
11from pathlib import Path
12 
13from patchright.sync_api import BrowserContext, Page
14 
15# Add parent directory to path
16sys.path.insert(0, str(Path(__file__).parent))
17 
18from browser_utils import StealthUtils
19 
20 
21class BrowserSession:
22    """
23    Represents a single persistent browser session for NotebookLM
24 
25    Each session gets its own Page (tab) within a shared BrowserContext,
26    allowing for contextual conversations where NotebookLM remembers
27    previous messages.
28    """
29 
30    def __init__(self, session_id: str, context: BrowserContext, notebook_url: str):
31        """
32        Initialize a new browser session
33 
34        Args:
35            session_id: Unique identifier for this session
36            context: Browser context (shared or dedicated)
37            notebook_url: Target NotebookLM URL for this session
38        """
39        self.id = session_id
40        self.created_at = time.time()
41        self.last_activity = time.time()
42        self.message_count = 0
43        self.notebook_url = notebook_url
44        self.context = context
45        self.page = None
46        self.stealth = StealthUtils()
47 
48        # Initialize the session
49        self._initialize()
50 
51    def _initialize(self):
52        """Initialize the browser session and navigate to NotebookLM"""
53        print(f"🚀 Creating session {self.id}...")
54 
55        # Create new page (tab) in context
56        self.page = self.context.new_page()
57        print(f"  🌐 Navigating to NotebookLM...")
58 
59        try:
60            # Navigate to notebook
61            self.page.goto(self.notebook_url, wait_until="domcontentloaded", timeout=30000)
62 
63            # Check if login is needed
64            if "accounts.google.com" in self.page.url:
65                raise RuntimeError("Authentication required. Please run auth_manager.py setup first.")
66 
67            # Wait for page to be ready
68            self._wait_for_ready()
69 
70            # Simulate human inspection
71            self.stealth.random_mouse_movement(self.page)
72            self.stealth.random_delay(300, 600)
73 
74            print(f"✅ Session {self.id} ready!")
75 
76        except Exception as e:
77            print(f"❌ Failed to initialize session: {e}")
78            if self.page:
79                self.page.close()
80            raise
81 
82    def _wait_for_ready(self):
83        """Wait for NotebookLM page to be ready"""
84        try:
85            # Wait for chat input
86            self.page.wait_for_selector("textarea.query-box-input", timeout=10000, state="visible")
87        except Exception:
88            # Try alternative selector
89            self.page.wait_for_selector('textarea[aria-label="Feld für Anfragen"]', timeout=5000, state="visible")
90 
91    def ask(self, question: str) -> Dict[str, Any]:
92        """
93        Ask a question in this session
94 
95        Args:
96            question: The question to ask
97 
98        Returns:
99            Dict with status, question, answer, session_id
100        """
101        try:
102            self.last_activity = time.time()
103            self.message_count += 1
104 
105            print(f"💬 [{self.id}] Asking: {question}")
106 
107            # Snapshot current answer to detect new response
108            previous_answer = self._snapshot_latest_response()
109 
110            # Find chat input
111            chat_input_selector = "textarea.query-box-input"
112            try:
113                self.page.wait_for_selector(chat_input_selector, timeout=5000, state="visible")
114            except Exception:
115                chat_input_selector = 'textarea[aria-label="Feld für Anfragen"]'
116                self.page.wait_for_selector(chat_input_selector, timeout=5000, state="visible")
117 
118            # Click and type with human-like behavior
119            self.stealth.realistic_click(self.page, chat_input_selector)
120            self.stealth.human_type(self.page, chat_input_selector, question)
121 
122            # Small pause before submit
123            self.stealth.random_delay(300, 800)
124 
125            # Submit
126            self.page.keyboard.press("Enter")
127 
128            # Wait for response
129            print("  ⏳ Waiting for response...")
130            self.stealth.random_delay(1500, 3000)
131 
132            # Get new answer
133            answer = self._wait_for_latest_answer(previous_answer)
134 
135            if not answer:
136                raise Exception("Empty response from NotebookLM")
137 
138            print(f"  ✅ Got response ({len(answer)} chars)")
139 
140            return {
141                "status": "success",
142                "question": question,
143                "answer": answer,
144                "session_id": self.id,
145                "notebook_url": self.notebook_url
146            }
147 
148        except Exception as e:
149            print(f"  ❌ Error: {e}")
150            return {
151                "status": "error",
152                "question": question,
153                "error": str(e),
154                "session_id": self.id
155            }
156 
157    def _snapshot_latest_response(self) -> Optional[str]:
158        """Get the current latest response text"""
159        try:
160            # Use correct NotebookLM selector
161            responses = self.page.query_selector_all(".to-user-container .message-text-content")
162            if responses:
163                return responses[-1].inner_text()
164        except Exception:
165            pass
166        return None
167 
168    def _wait_for_latest_answer(self, previous_answer: Optional[str], timeout: int = 120) -> str:
169        """Wait for and extract the new answer"""
170        start_time = time.time()
171        last_candidate = None
172        stable_count = 0
173 
174        while time.time() - start_time < timeout:
175            # Check if NotebookLM is still thinking (most reliable indicator)
176            try:
177                thinking_element = self.page.query_selector('div.thinking-message')
178                if thinking_element and thinking_element.is_visible():
179                    time.sleep(0.5)
180                    continue
181            except Exception:
182                pass
183 
184            try:
185                # Use correct NotebookLM selector
186                responses = self.page.query_selector_all(".to-user-container .message-text-content")
187 
188                if responses:
189                    latest_text = responses[-1].inner_text().strip()
190 
191                    # Check if it's a new response
192                    if latest_text and latest_text != previous_answer:
193                        # Check if text is stable (3 consecutive polls)
194                        if latest_text == last_candidate:
195                            stable_count += 1
196                            if stable_count >= 3:
197                                return latest_text
198                        else:
199                            stable_count = 1
200                            last_candidate = latest_text
201 
202            except Exception:
203                pass
204 
205            time.sleep(0.5)
206 
207        raise TimeoutError(f"No response received within {timeout} seconds")
208 
209    def reset(self):
210        """Reset the chat by reloading the page"""
211        print(f"🔄 Resetting session {self.id}...")
212 
213        self.page.reload(wait_until="domcontentloaded")
214        self._wait_for_ready()
215 
216        previous_count = self.message_count
217        self.message_count = 0
218        self.last_activity = time.time()
219 
220        print(f"✅ Session reset (cleared {previous_count} messages)")
221        return previous_count
222 
223    def close(self):
224        """Close this session and clean up resources"""
225        print(f"🛑 Closing session {self.id}...")
226 
227        if self.page:
228            try:
229                self.page.close()
230            except Exception as e:
231                print(f"  ⚠️ Error closing page: {e}")
232 
233        print(f"✅ Session {self.id} closed")
234 
235    def get_info(self) -> Dict[str, Any]:
236        """Get information about this session"""
237        return {
238            "id": self.id,
239            "created_at": self.created_at,
240            "last_activity": self.last_activity,
241            "age_seconds": time.time() - self.created_at,
242            "inactive_seconds": time.time() - self.last_activity,
243            "message_count": self.message_count,
244            "notebook_url": self.notebook_url
245        }
246 
247    def is_expired(self, timeout_seconds: int = 900) -> bool:
248        """Check if session has expired (default: 15 minutes)"""
249        return (time.time() - self.last_activity) > timeout_seconds
250 
251 
252if __name__ == "__main__":
253    # Example usage
254    print("Browser Session Module - Use ask_question.py for main interface")
255    print("This module provides low-level browser session management.")