bps-kit 1.0.1 → 1.0.2

package/templates/vault/notebooklm/scripts/browser_session.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""
+Browser Session Management for NotebookLM
+Individual browser session for persistent NotebookLM conversations
+Based on the original NotebookLM API implementation
+"""
+
+import time
+import sys
+from typing import Any, Dict, Optional
+from pathlib import Path
+
+from patchright.sync_api import BrowserContext, Page
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from browser_utils import StealthUtils
+
+
+class BrowserSession:
+    """
+    Represents a single persistent browser session for NotebookLM
+
+    Each session gets its own Page (tab) within a shared BrowserContext,
+    allowing for contextual conversations where NotebookLM remembers
+    previous messages.
+    """
+
+    def __init__(self, session_id: str, context: BrowserContext, notebook_url: str):
+        """
+        Initialize a new browser session
+
+        Args:
+            session_id: Unique identifier for this session
+            context: Browser context (shared or dedicated)
+            notebook_url: Target NotebookLM URL for this session
+        """
+        self.id = session_id
+        self.created_at = time.time()
+        self.last_activity = time.time()
+        self.message_count = 0
+        self.notebook_url = notebook_url
+        self.context = context
+        self.page = None
+        self.stealth = StealthUtils()
+
+        # Initialize the session
+        self._initialize()
+
+    def _initialize(self):
+        """Initialize the browser session and navigate to NotebookLM"""
+        print(f"🚀 Creating session {self.id}...")
+
+        # Create new page (tab) in context
+        self.page = self.context.new_page()
+        print(f"  🌐 Navigating to NotebookLM...")
+
+        try:
+            # Navigate to notebook
+            self.page.goto(self.notebook_url, wait_until="domcontentloaded", timeout=30000)
+
+            # Check if login is needed
+            if "accounts.google.com" in self.page.url:
+                raise RuntimeError("Authentication required. Please run auth_manager.py setup first.")
+
+            # Wait for page to be ready
+            self._wait_for_ready()
+
+            # Simulate human inspection
+            self.stealth.random_mouse_movement(self.page)
+            self.stealth.random_delay(300, 600)
+
+            print(f"✅ Session {self.id} ready!")
+
+        except Exception as e:
+            print(f"❌ Failed to initialize session: {e}")
+            if self.page:
+                self.page.close()
+            raise
+
+    def _wait_for_ready(self):
+        """Wait for NotebookLM page to be ready"""
+        try:
+            # Wait for chat input
+            self.page.wait_for_selector("textarea.query-box-input", timeout=10000, state="visible")
+        except Exception:
+            # Try alternative selector
+            self.page.wait_for_selector('textarea[aria-label="Feld für Anfragen"]', timeout=5000, state="visible")
+
+    def ask(self, question: str) -> Dict[str, Any]:
+        """
+        Ask a question in this session
+
+        Args:
+            question: The question to ask
+
+        Returns:
+            Dict with status, question, answer, session_id
+        """
+        try:
+            self.last_activity = time.time()
+            self.message_count += 1
+
+            print(f"💬 [{self.id}] Asking: {question}")
+
+            # Snapshot current answer to detect new response
+            previous_answer = self._snapshot_latest_response()
+
+            # Find chat input
+            chat_input_selector = "textarea.query-box-input"
+            try:
+                self.page.wait_for_selector(chat_input_selector, timeout=5000, state="visible")
+            except Exception:
+                chat_input_selector = 'textarea[aria-label="Feld für Anfragen"]'
+                self.page.wait_for_selector(chat_input_selector, timeout=5000, state="visible")
+
+            # Click and type with human-like behavior
+            self.stealth.realistic_click(self.page, chat_input_selector)
+            self.stealth.human_type(self.page, chat_input_selector, question)
+
+            # Small pause before submit
+            self.stealth.random_delay(300, 800)
+
+            # Submit
+            self.page.keyboard.press("Enter")
+
+            # Wait for response
+            print("  ⏳ Waiting for response...")
+            self.stealth.random_delay(1500, 3000)
+
+            # Get new answer
+            answer = self._wait_for_latest_answer(previous_answer)
+
+            if not answer:
+                raise Exception("Empty response from NotebookLM")
+
+            print(f"  ✅ Got response ({len(answer)} chars)")
+
+            return {
+                "status": "success",
+                "question": question,
+                "answer": answer,
+                "session_id": self.id,
+                "notebook_url": self.notebook_url
+            }
+
+        except Exception as e:
+            print(f"  ❌ Error: {e}")
+            return {
+                "status": "error",
+                "question": question,
+                "error": str(e),
+                "session_id": self.id
+            }
+
+    def _snapshot_latest_response(self) -> Optional[str]:
+        """Get the current latest response text"""
+        try:
+            # Use correct NotebookLM selector
+            responses = self.page.query_selector_all(".to-user-container .message-text-content")
+            if responses:
+                return responses[-1].inner_text()
+        except Exception:
+            pass
+        return None
+
+    def _wait_for_latest_answer(self, previous_answer: Optional[str], timeout: int = 120) -> str:
+        """Wait for and extract the new answer"""
+        start_time = time.time()
+        last_candidate = None
+        stable_count = 0
+
+        while time.time() - start_time < timeout:
+            # Check if NotebookLM is still thinking (most reliable indicator)
+            try:
+                thinking_element = self.page.query_selector('div.thinking-message')
+                if thinking_element and thinking_element.is_visible():
+                    time.sleep(0.5)
+                    continue
+            except Exception:
+                pass
+
+            try:
+                # Use correct NotebookLM selector
+                responses = self.page.query_selector_all(".to-user-container .message-text-content")
+
+                if responses:
+                    latest_text = responses[-1].inner_text().strip()
+
+                    # Check if it's a new response
+                    if latest_text and latest_text != previous_answer:
+                        # Check if text is stable (3 consecutive polls)
+                        if latest_text == last_candidate:
+                            stable_count += 1
+                            if stable_count >= 3:
+                                return latest_text
+                        else:
+                            stable_count = 1
+                            last_candidate = latest_text
+
+            except Exception:
+                pass
+
+            time.sleep(0.5)
+
+        raise TimeoutError(f"No response received within {timeout} seconds")
+
+    def reset(self):
+        """Reset the chat by reloading the page"""
+        print(f"🔄 Resetting session {self.id}...")
+
+        self.page.reload(wait_until="domcontentloaded")
+        self._wait_for_ready()
+
+        previous_count = self.message_count
+        self.message_count = 0
+        self.last_activity = time.time()
+
+        print(f"✅ Session reset (cleared {previous_count} messages)")
+        return previous_count
+
+    def close(self):
+        """Close this session and clean up resources"""
+        print(f"🛑 Closing session {self.id}...")
+
+        if self.page:
+            try:
+                self.page.close()
+            except Exception as e:
+                print(f"  ⚠️ Error closing page: {e}")
+
+        print(f"✅ Session {self.id} closed")
+
+    def get_info(self) -> Dict[str, Any]:
+        """Get information about this session"""
+        return {
+            "id": self.id,
+            "created_at": self.created_at,
+            "last_activity": self.last_activity,
+            "age_seconds": time.time() - self.created_at,
+            "inactive_seconds": time.time() - self.last_activity,
+            "message_count": self.message_count,
+            "notebook_url": self.notebook_url
+        }
+
+    def is_expired(self, timeout_seconds: int = 900) -> bool:
+        """Check if session has expired (default: 15 minutes)"""
+        return (time.time() - self.last_activity) > timeout_seconds
+
+
+if __name__ == "__main__":
+    # Example usage
+    print("Browser Session Module - Use ask_question.py for main interface")
+    print("This module provides low-level browser session management.")

package/templates/vault/notebooklm/scripts/browser_utils.py

@@ -0,0 +1,107 @@
+"""
+Browser Utilities for NotebookLM Skill
+Handles browser launching, stealth features, and common interactions
+"""
+
+import json
+import time
+import random
+from typing import Optional, List
+
+from patchright.sync_api import Playwright, BrowserContext, Page
+from config import BROWSER_PROFILE_DIR, STATE_FILE, BROWSER_ARGS, USER_AGENT
+
+
+class BrowserFactory:
+    """Factory for creating configured browser contexts"""
+
+    @staticmethod
+    def launch_persistent_context(
+        playwright: Playwright,
+        headless: bool = True,
+        user_data_dir: str = str(BROWSER_PROFILE_DIR)
+    ) -> BrowserContext:
+        """
+        Launch a persistent browser context with anti-detection features
+        and cookie workaround.
+        """
+        # Launch persistent context
+        context = playwright.chromium.launch_persistent_context(
+            user_data_dir=user_data_dir,
+            channel="chrome",  # Use real Chrome
+            headless=headless,
+            no_viewport=True,
+            ignore_default_args=["--enable-automation"],
+            user_agent=USER_AGENT,
+            args=BROWSER_ARGS
+        )
+
+        # Cookie Workaround for Playwright bug #36139
+        # Session cookies (expires=-1) don't persist in user_data_dir automatically
+        BrowserFactory._inject_cookies(context)
+
+        return context
+
+    @staticmethod
+    def _inject_cookies(context: BrowserContext):
+        """Inject cookies from state.json if available"""
+        if STATE_FILE.exists():
+            try:
+                with open(STATE_FILE, 'r') as f:
+                    state = json.load(f)
+                    if 'cookies' in state and len(state['cookies']) > 0:
+                        context.add_cookies(state['cookies'])
+                        # print(f"  🔧 Injected {len(state['cookies'])} cookies from state.json")
+            except Exception as e:
+                print(f"  ⚠️  Could not load state.json: {e}")
+
+
+class StealthUtils:
+    """Human-like interaction utilities"""
+
+    @staticmethod
+    def random_delay(min_ms: int = 100, max_ms: int = 500):
+        """Add random delay"""
+        time.sleep(random.uniform(min_ms / 1000, max_ms / 1000))
+
+    @staticmethod
+    def human_type(page: Page, selector: str, text: str, wpm_min: int = 320, wpm_max: int = 480):
+        """Type with human-like speed"""
+        element = page.query_selector(selector)
+        if not element:
+            # Try waiting if not immediately found
+            try:
+                element = page.wait_for_selector(selector, timeout=2000)
+            except:
+                pass
+        
+        if not element:
+            print(f"⚠️ Element not found for typing: {selector}")
+            return
+
+        # Click to focus
+        element.click()
+        
+        # Type
+        for char in text:
+            element.type(char, delay=random.uniform(25, 75))
+            if random.random() < 0.05:
+                time.sleep(random.uniform(0.15, 0.4))
+
+    @staticmethod
+    def realistic_click(page: Page, selector: str):
+        """Click with realistic movement"""
+        element = page.query_selector(selector)
+        if not element:
+            return
+
+        # Optional: Move mouse to element (simplified)
+        box = element.bounding_box()
+        if box:
+            x = box['x'] + box['width'] / 2
+            y = box['y'] + box['height'] / 2
+            page.mouse.move(x, y, steps=5)
+
+        StealthUtils.random_delay(100, 300)
+        element.click()
+        StealthUtils.random_delay(100, 300)

package/templates/vault/notebooklm/scripts/cleanup_manager.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""
+Cleanup Manager for NotebookLM Skill
+Manages cleanup of skill data and browser state
+"""
+
+import shutil
+import argparse
+from pathlib import Path
+from typing import Dict, List, Any
+
+
+class CleanupManager:
+    """
+    Manages cleanup of NotebookLM skill data
+
+    Features:
+    - Preview what will be deleted
+    - Selective cleanup options
+    - Library preservation
+    - Safe deletion with confirmation
+    """
+
+    def __init__(self):
+        """Initialize the cleanup manager"""
+        # Skill directory paths
+        self.skill_dir = Path(__file__).parent.parent
+        self.data_dir = self.skill_dir / "data"
+
+    def get_cleanup_paths(self, preserve_library: bool = False) -> Dict[str, Any]:
+        """
+        Get paths that would be cleaned up
+
+        Args:
+            preserve_library: Keep library.json if True
+
+        Returns:
+            Dict with paths and sizes
+
+        Note: .venv is NEVER deleted - it's part of the skill infrastructure
+        """
+        paths = {
+            'browser_state': [],
+            'sessions': [],
+            'library': [],
+            'auth': [],
+            'other': []
+        }
+
+        total_size = 0
+
+        if self.data_dir.exists():
+            # Browser state
+            browser_state_dir = self.data_dir / "browser_state"
+            if browser_state_dir.exists():
+                for item in browser_state_dir.iterdir():
+                    size = self._get_size(item)
+                    paths['browser_state'].append({
+                        'path': str(item),
+                        'size': size,
+                        'type': 'dir' if item.is_dir() else 'file'
+                    })
+                    total_size += size
+
+            # Sessions
+            sessions_file = self.data_dir / "sessions.json"
+            if sessions_file.exists():
+                size = sessions_file.stat().st_size
+                paths['sessions'].append({
+                    'path': str(sessions_file),
+                    'size': size,
+                    'type': 'file'
+                })
+                total_size += size
+
+            # Library (unless preserved)
+            if not preserve_library:
+                library_file = self.data_dir / "library.json"
+                if library_file.exists():
+                    size = library_file.stat().st_size
+                    paths['library'].append({
+                        'path': str(library_file),
+                        'size': size,
+                        'type': 'file'
+                    })
+                    total_size += size
+
+            # Auth info
+            auth_info = self.data_dir / "auth_info.json"
+            if auth_info.exists():
+                size = auth_info.stat().st_size
+                paths['auth'].append({
+                    'path': str(auth_info),
+                    'size': size,
+                    'type': 'file'
+                })
+                total_size += size
+
+            # Other files in data dir (but NEVER .venv!)
+            for item in self.data_dir.iterdir():
+                if item.name not in ['browser_state', 'sessions.json', 'library.json', 'auth_info.json']:
+                    size = self._get_size(item)
+                    paths['other'].append({
+                        'path': str(item),
+                        'size': size,
+                        'type': 'dir' if item.is_dir() else 'file'
+                    })
+                    total_size += size
+
+        return {
+            'categories': paths,
+            'total_size': total_size,
+            'total_items': sum(len(items) for items in paths.values())
+        }
+
+    def _get_size(self, path: Path) -> int:
+        """Get size of file or directory in bytes"""
+        if path.is_file():
+            return path.stat().st_size
+        elif path.is_dir():
+            total = 0
+            try:
+                for item in path.rglob('*'):
+                    if item.is_file():
+                        total += item.stat().st_size
+            except Exception:
+                pass
+            return total
+        return 0
+
+    def _format_size(self, size: int) -> str:
+        """Format size in human-readable form"""
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if size < 1024:
+                return f"{size:.1f} {unit}"
+            size /= 1024
+        return f"{size:.1f} TB"
+
+    def perform_cleanup(
+        self,
+        preserve_library: bool = False,
+        dry_run: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Perform the actual cleanup
+
+        Args:
+            preserve_library: Keep library.json if True
+            dry_run: Preview only, don't delete
+
+        Returns:
+            Dict with cleanup results
+        """
+        cleanup_data = self.get_cleanup_paths(preserve_library)
+        deleted_items = []
+        failed_items = []
+        deleted_size = 0
+
+        if dry_run:
+            return {
+                'dry_run': True,
+                'would_delete': cleanup_data['total_items'],
+                'would_free': cleanup_data['total_size']
+            }
+
+        # Perform deletion
+        for category, items in cleanup_data['categories'].items():
+            for item_info in items:
+                path = Path(item_info['path'])
+                try:
+                    if path.exists():
+                        if path.is_dir():
+                            shutil.rmtree(path)
+                        else:
+                            path.unlink()
+                        deleted_items.append(str(path))
+                        deleted_size += item_info['size']
+                        print(f"  ✅ Deleted: {path.name}")
+                except Exception as e:
+                    failed_items.append({
+                        'path': str(path),
+                        'error': str(e)
+                    })
+                    print(f"  ❌ Failed: {path.name} ({e})")
+
+        # Recreate browser_state dir if everything was deleted
+        if not preserve_library and not failed_items:
+            browser_state_dir = self.data_dir / "browser_state"
+            browser_state_dir.mkdir(parents=True, exist_ok=True)
+
+        return {
+            'deleted_items': deleted_items,
+            'failed_items': failed_items,
+            'deleted_size': deleted_size,
+            'deleted_count': len(deleted_items),
+            'failed_count': len(failed_items)
+        }
+
+    def print_cleanup_preview(self, preserve_library: bool = False):
+        """Print a preview of what will be cleaned"""
+        data = self.get_cleanup_paths(preserve_library)
+
+        print("\n🔍 Cleanup Preview")
+        print("=" * 60)
+
+        for category, items in data['categories'].items():
+            if items:
+                print(f"\n📁 {category.replace('_', ' ').title()}:")
+                for item in items:
+                    path = Path(item['path'])
+                    size_str = self._format_size(item['size'])
+                    type_icon = "📂" if item['type'] == 'dir' else "📄"
+                    print(f"  {type_icon} {path.name:<30} {size_str:>10}")
+
+        print("\n" + "=" * 60)
+        print(f"Total items: {data['total_items']}")
+        print(f"Total size: {self._format_size(data['total_size'])}")
+
+        if preserve_library:
+            print("\n📚 Library will be preserved")
+
+        print("\nThis preview shows what would be deleted.")
+        print("Use --confirm to actually perform the cleanup.")
+
+
+def main():
+    """Command-line interface for cleanup management"""
+    parser = argparse.ArgumentParser(
+        description='Clean up NotebookLM skill data',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Preview what will be deleted
+  python cleanup_manager.py
+
+  # Perform cleanup (delete everything)
+  python cleanup_manager.py --confirm
+
+  # Cleanup but keep library
+  python cleanup_manager.py --confirm --preserve-library
+
+  # Force cleanup without preview
+  python cleanup_manager.py --confirm --force
+        """
+    )
+
+    parser.add_argument(
+        '--confirm',
+        action='store_true',
+        help='Actually perform the cleanup (without this, only preview)'
+    )
+
+    parser.add_argument(
+        '--preserve-library',
+        action='store_true',
+        help='Keep the notebook library (library.json)'
+    )
+
+    parser.add_argument(
+        '--force',
+        action='store_true',
+        help='Skip confirmation prompt'
+    )
+
+    args = parser.parse_args()
+
+    # Initialize manager
+    manager = CleanupManager()
+
+    if args.confirm:
+        # Show preview first unless forced
+        if not args.force:
+            manager.print_cleanup_preview(args.preserve_library)
+
+            print("\n⚠️  WARNING: This will delete the files shown above!")
+            print("   Note: .venv is preserved (part of skill infrastructure)")
+            response = input("Are you sure? (yes/no): ")
+
+            if response.lower() != 'yes':
+                print("Cleanup cancelled.")
+                return
+
+        # Perform cleanup
+        print("\n🗑️ Performing cleanup...")
+        result = manager.perform_cleanup(args.preserve_library, dry_run=False)
+
+        print(f"\n✅ Cleanup complete!")
+        print(f"  Deleted: {result['deleted_count']} items")
+        print(f"  Freed: {manager._format_size(result['deleted_size'])}")
+
+        if result['failed_count'] > 0:
+            print(f"  ⚠️ Failed: {result['failed_count']} items")
+
+    else:
+        # Just show preview
+        manager.print_cleanup_preview(args.preserve_library)
+        print("\n💡 Note: Virtual environment (.venv) is never deleted")
+        print("   It's part of the skill infrastructure, not user data")
+
+
+if __name__ == "__main__":
+    main()