bps-kit 1.0.1 → 1.0.2

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

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+NotebookLM Skill Scripts Package
+Provides automatic environment management for all scripts
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+
+def ensure_venv_and_run():
+    """
+    Ensure virtual environment exists and run the requested script.
+    This is called when any script is imported or run directly.
+    """
+    # Only do this if we're not already in the skill's venv
+    skill_dir = Path(__file__).parent.parent
+    venv_dir = skill_dir / ".venv"
+
+    # Check if we're in a venv
+    in_venv = hasattr(sys, 'real_prefix') or (
+        hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
+    )
+
+    # Check if it's OUR venv
+    if in_venv:
+        venv_path = Path(sys.prefix)
+        if venv_path == venv_dir:
+            # We're already in the correct venv
+            return
+
+    # We need to set up or switch to our venv
+    if not venv_dir.exists():
+        print("🔧 First-time setup detected...")
+        print("   Creating isolated environment for NotebookLM skill...")
+        print("   This ensures clean dependency management...")
+
+        # Create venv
+        import venv
+        venv.create(venv_dir, with_pip=True)
+
+        # Install requirements
+        requirements_file = skill_dir / "requirements.txt"
+        if requirements_file.exists():
+            if os.name == 'nt':  # Windows
+                pip_exe = venv_dir / "Scripts" / "pip.exe"
+            else:
+                pip_exe = venv_dir / "bin" / "pip"
+
+            print("   Installing dependencies in isolated environment...")
+            subprocess.run(
+                [str(pip_exe), "install", "-q", "-r", str(requirements_file)],
+                check=True
+            )
+
+            # Also install patchright's chromium
+            print("   Setting up browser automation...")
+            if os.name == 'nt':
+                python_exe = venv_dir / "Scripts" / "python.exe"
+            else:
+                python_exe = venv_dir / "bin" / "python"
+
+            subprocess.run(
+                [str(python_exe), "-m", "patchright", "install", "chromium"],
+                check=True,
+                capture_output=True
+            )
+
+        print("✅ Environment ready! All dependencies isolated in .venv/")
+
+    # If we're here and not in the venv, we should recommend using the venv
+    if not in_venv:
+        print("\n⚠️  Running outside virtual environment")
+        print("   Recommended: Use scripts/run.py to ensure clean execution")
+        print("   Or activate: source .venv/bin/activate")
+
+
+# Check environment when module is imported
+ensure_venv_and_run()

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

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+Simple NotebookLM Question Interface
+Based on MCP server implementation - simplified without sessions
+
+Implements hybrid auth approach:
+- Persistent browser profile (user_data_dir) for fingerprint consistency
+- Manual cookie injection from state.json for session cookies (Playwright bug workaround)
+See: https://github.com/microsoft/playwright/issues/36139
+"""
+
+import argparse
+import sys
+import time
+import re
+from pathlib import Path
+
+from patchright.sync_api import sync_playwright
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from auth_manager import AuthManager
+from notebook_manager import NotebookLibrary
+from config import QUERY_INPUT_SELECTORS, RESPONSE_SELECTORS
+from browser_utils import BrowserFactory, StealthUtils
+
+
+# Follow-up reminder (adapted from MCP server for stateless operation)
+# Since we don't have persistent sessions, we encourage comprehensive questions
+FOLLOW_UP_REMINDER = (
+    "\n\nEXTREMELY IMPORTANT: Is that ALL you need to know? "
+    "You can always ask another question! Think about it carefully: "
+    "before you reply to the user, review their original request and this answer. "
+    "If anything is still unclear or missing, ask me another comprehensive question "
+    "that includes all necessary context (since each question opens a new browser session)."
+)
+
+
+def ask_notebooklm(question: str, notebook_url: str, headless: bool = True) -> str:
+    """
+    Ask a question to NotebookLM
+
+    Args:
+        question: Question to ask
+        notebook_url: NotebookLM notebook URL
+        headless: Run browser in headless mode
+
+    Returns:
+        Answer text from NotebookLM
+    """
+    auth = AuthManager()
+
+    if not auth.is_authenticated():
+        print("⚠️ Not authenticated. Run: python auth_manager.py setup")
+        return None
+
+    print(f"💬 Asking: {question}")
+    print(f"📚 Notebook: {notebook_url}")
+
+    playwright = None
+    context = None
+
+    try:
+        # Start playwright
+        playwright = sync_playwright().start()
+
+        # Launch persistent browser context using factory
+        context = BrowserFactory.launch_persistent_context(
+            playwright,
+            headless=headless
+        )
+
+        # Navigate to notebook
+        page = context.new_page()
+        print("  🌐 Opening notebook...")
+        page.goto(notebook_url, wait_until="domcontentloaded")
+
+        # Wait for NotebookLM
+        page.wait_for_url(re.compile(r"^https://notebooklm\.google\.com/"), timeout=10000)
+
+        # Wait for query input (MCP approach)
+        print("  ⏳ Waiting for query input...")
+        query_element = None
+
+        for selector in QUERY_INPUT_SELECTORS:
+            try:
+                query_element = page.wait_for_selector(
+                    selector,
+                    timeout=10000,
+                    state="visible"  # Only check visibility, not disabled!
+                )
+                if query_element:
+                    print(f"  ✓ Found input: {selector}")
+                    break
+            except:
+                continue
+
+        if not query_element:
+            print("  ❌ Could not find query input")
+            return None
+
+        # Type question (human-like, fast)
+        print("  ⏳ Typing question...")
+        
+        # Use primary selector for typing
+        input_selector = QUERY_INPUT_SELECTORS[0]
+        StealthUtils.human_type(page, input_selector, question)
+
+        # Submit
+        print("  📤 Submitting...")
+        page.keyboard.press("Enter")
+
+        # Small pause
+        StealthUtils.random_delay(500, 1500)
+
+        # Wait for response (MCP approach: poll for stable text)
+        print("  ⏳ Waiting for answer...")
+
+        answer = None
+        stable_count = 0
+        last_text = None
+        deadline = time.time() + 120  # 2 minutes timeout
+
+        while time.time() < deadline:
+            # Check if NotebookLM is still thinking (most reliable indicator)
+            try:
+                thinking_element = page.query_selector('div.thinking-message')
+                if thinking_element and thinking_element.is_visible():
+                    time.sleep(1)
+                    continue
+            except:
+                pass
+
+            # Try to find response with MCP selectors
+            for selector in RESPONSE_SELECTORS:
+                try:
+                    elements = page.query_selector_all(selector)
+                    if elements:
+                        # Get last (newest) response
+                        latest = elements[-1]
+                        text = latest.inner_text().strip()
+
+                        if text:
+                            if text == last_text:
+                                stable_count += 1
+                                if stable_count >= 3:  # Stable for 3 polls
+                                    answer = text
+                                    break
+                            else:
+                                stable_count = 0
+                                last_text = text
+                except:
+                    continue
+
+            if answer:
+                break
+
+            time.sleep(1)
+
+        if not answer:
+            print("  ❌ Timeout waiting for answer")
+            return None
+
+        print("  ✅ Got answer!")
+        # Add follow-up reminder to encourage Claude to ask more questions
+        return answer + FOLLOW_UP_REMINDER
+
+    except Exception as e:
+        print(f"  ❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+    finally:
+        # Always clean up
+        if context:
+            try:
+                context.close()
+            except:
+                pass
+
+        if playwright:
+            try:
+                playwright.stop()
+            except:
+                pass
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Ask NotebookLM a question')
+
+    parser.add_argument('--question', required=True, help='Question to ask')
+    parser.add_argument('--notebook-url', help='NotebookLM notebook URL')
+    parser.add_argument('--notebook-id', help='Notebook ID from library')
+    parser.add_argument('--show-browser', action='store_true', help='Show browser')
+
+    args = parser.parse_args()
+
+    # Resolve notebook URL
+    notebook_url = args.notebook_url
+
+    if not notebook_url and args.notebook_id:
+        library = NotebookLibrary()
+        notebook = library.get_notebook(args.notebook_id)
+        if notebook:
+            notebook_url = notebook['url']
+        else:
+            print(f"❌ Notebook '{args.notebook_id}' not found")
+            return 1
+
+    if not notebook_url:
+        # Check for active notebook first
+        library = NotebookLibrary()
+        active = library.get_active_notebook()
+        if active:
+            notebook_url = active['url']
+            print(f"📚 Using active notebook: {active['name']}")
+        else:
+            # Show available notebooks
+            notebooks = library.list_notebooks()
+            if notebooks:
+                print("\n📚 Available notebooks:")
+                for nb in notebooks:
+                    mark = " [ACTIVE]" if nb.get('id') == library.active_notebook_id else ""
+                    print(f"  {nb['id']}: {nb['name']}{mark}")
+                print("\nSpecify with --notebook-id or set active:")
+                print("python scripts/run.py notebook_manager.py activate --id ID")
+            else:
+                print("❌ No notebooks in library. Add one first:")
+                print("python scripts/run.py notebook_manager.py add --url URL --name NAME --description DESC --topics TOPICS")
+            return 1
+
+    # Ask the question
+    answer = ask_notebooklm(
+        question=args.question,
+        notebook_url=notebook_url,
+        headless=not args.show_browser
+    )
+
+    if answer:
+        print("\n" + "=" * 60)
+        print(f"Question: {args.question}")
+        print("=" * 60)
+        print()
+        print(answer)
+        print()
+        print("=" * 60)
+        return 0
+    else:
+        print("\n❌ Failed to get answer")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,358 @@
+#!/usr/bin/env python3
+"""
+Authentication Manager for NotebookLM
+Handles Google login and browser state persistence
+Based on the MCP server implementation
+
+Implements hybrid auth approach:
+- Persistent browser profile (user_data_dir) for fingerprint consistency
+- Manual cookie injection from state.json for session cookies (Playwright bug workaround)
+See: https://github.com/microsoft/playwright/issues/36139
+"""
+
+import json
+import time
+import argparse
+import shutil
+import re
+import sys
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+from patchright.sync_api import sync_playwright, BrowserContext
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from config import BROWSER_STATE_DIR, STATE_FILE, AUTH_INFO_FILE, DATA_DIR
+from browser_utils import BrowserFactory
+
+
+class AuthManager:
+    """
+    Manages authentication and browser state for NotebookLM
+
+    Features:
+    - Interactive Google login
+    - Browser state persistence
+    - Session restoration
+    - Account switching
+    """
+
+    def __init__(self):
+        """Initialize the authentication manager"""
+        # Ensure directories exist
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+        BROWSER_STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+        self.state_file = STATE_FILE
+        self.auth_info_file = AUTH_INFO_FILE
+        self.browser_state_dir = BROWSER_STATE_DIR
+
+    def is_authenticated(self) -> bool:
+        """Check if valid authentication exists"""
+        if not self.state_file.exists():
+            return False
+
+        # Check if state file is not too old (7 days)
+        age_days = (time.time() - self.state_file.stat().st_mtime) / 86400
+        if age_days > 7:
+            print(f"⚠️ Browser state is {age_days:.1f} days old, may need re-authentication")
+
+        return True
+
+    def get_auth_info(self) -> Dict[str, Any]:
+        """Get authentication information"""
+        info = {
+            'authenticated': self.is_authenticated(),
+            'state_file': str(self.state_file),
+            'state_exists': self.state_file.exists()
+        }
+
+        if self.auth_info_file.exists():
+            try:
+                with open(self.auth_info_file, 'r') as f:
+                    saved_info = json.load(f)
+                    info.update(saved_info)
+            except Exception:
+                pass
+
+        if info['state_exists']:
+            age_hours = (time.time() - self.state_file.stat().st_mtime) / 3600
+            info['state_age_hours'] = age_hours
+
+        return info
+
+    def setup_auth(self, headless: bool = False, timeout_minutes: int = 10) -> bool:
+        """
+        Perform interactive authentication setup
+
+        Args:
+            headless: Run browser in headless mode (False for login)
+            timeout_minutes: Maximum time to wait for login
+
+        Returns:
+            True if authentication successful
+        """
+        print("🔐 Starting authentication setup...")
+        print(f"  Timeout: {timeout_minutes} minutes")
+
+        playwright = None
+        context = None
+
+        try:
+            playwright = sync_playwright().start()
+
+            # Launch using factory
+            context = BrowserFactory.launch_persistent_context(
+                playwright,
+                headless=headless
+            )
+
+            # Navigate to NotebookLM
+            page = context.new_page()
+            page.goto("https://notebooklm.google.com", wait_until="domcontentloaded")
+
+            # Check if already authenticated
+            if "notebooklm.google.com" in page.url and "accounts.google.com" not in page.url:
+                print("  ✅ Already authenticated!")
+                self._save_browser_state(context)
+                return True
+
+            # Wait for manual login
+            print("\n  ⏳ Please log in to your Google account...")
+            print(f"  ⏱️  Waiting up to {timeout_minutes} minutes for login...")
+
+            try:
+                # Wait for URL to change to NotebookLM (regex ensures it's the actual domain, not a parameter)
+                timeout_ms = int(timeout_minutes * 60 * 1000)
+                page.wait_for_url(re.compile(r"^https://notebooklm\.google\.com/"), timeout=timeout_ms)
+
+                print(f"  ✅ Login successful!")
+
+                # Save authentication state
+                self._save_browser_state(context)
+                self._save_auth_info()
+                return True
+
+            except Exception as e:
+                print(f"  ❌ Authentication timeout: {e}")
+                return False
+
+        except Exception as e:
+            print(f"  ❌ Error: {e}")
+            return False
+
+        finally:
+            # Clean up browser resources
+            if context:
+                try:
+                    context.close()
+                except Exception:
+                    pass
+
+            if playwright:
+                try:
+                    playwright.stop()
+                except Exception:
+                    pass
+
+    def _save_browser_state(self, context: BrowserContext):
+        """Save browser state to disk"""
+        try:
+            # Save storage state (cookies, localStorage)
+            context.storage_state(path=str(self.state_file))
+            print(f"  💾 Saved browser state to: {self.state_file}")
+        except Exception as e:
+            print(f"  ❌ Failed to save browser state: {e}")
+            raise
+
+    def _save_auth_info(self):
+        """Save authentication metadata"""
+        try:
+            info = {
+                'authenticated_at': time.time(),
+                'authenticated_at_iso': time.strftime('%Y-%m-%d %H:%M:%S')
+            }
+            with open(self.auth_info_file, 'w') as f:
+                json.dump(info, f, indent=2)
+        except Exception:
+            pass  # Non-critical
+
+    def clear_auth(self) -> bool:
+        """
+        Clear all authentication data
+
+        Returns:
+            True if cleared successfully
+        """
+        print("🗑️ Clearing authentication data...")
+
+        try:
+            # Remove browser state
+            if self.state_file.exists():
+                self.state_file.unlink()
+                print("  ✅ Removed browser state")
+
+            # Remove auth info
+            if self.auth_info_file.exists():
+                self.auth_info_file.unlink()
+                print("  ✅ Removed auth info")
+
+            # Clear entire browser state directory
+            if self.browser_state_dir.exists():
+                shutil.rmtree(self.browser_state_dir)
+                self.browser_state_dir.mkdir(parents=True, exist_ok=True)
+                print("  ✅ Cleared browser data")
+
+            return True
+
+        except Exception as e:
+            print(f"  ❌ Error clearing auth: {e}")
+            return False
+
+    def re_auth(self, headless: bool = False, timeout_minutes: int = 10) -> bool:
+        """
+        Perform re-authentication (clear and setup)
+
+        Args:
+            headless: Run browser in headless mode
+            timeout_minutes: Login timeout in minutes
+
+        Returns:
+            True if successful
+        """
+        print("🔄 Starting re-authentication...")
+
+        # Clear existing auth
+        self.clear_auth()
+
+        # Setup new auth
+        return self.setup_auth(headless, timeout_minutes)
+
+    def validate_auth(self) -> bool:
+        """
+        Validate that stored authentication works
+        Uses persistent context to match actual usage pattern
+
+        Returns:
+            True if authentication is valid
+        """
+        if not self.is_authenticated():
+            return False
+
+        print("🔍 Validating authentication...")
+
+        playwright = None
+        context = None
+
+        try:
+            playwright = sync_playwright().start()
+
+            # Launch using factory
+            context = BrowserFactory.launch_persistent_context(
+                playwright,
+                headless=True
+            )
+
+            # Try to access NotebookLM
+            page = context.new_page()
+            page.goto("https://notebooklm.google.com", wait_until="domcontentloaded", timeout=30000)
+
+            # Check if we can access NotebookLM
+            if "notebooklm.google.com" in page.url and "accounts.google.com" not in page.url:
+                print("  ✅ Authentication is valid")
+                return True
+            else:
+                print("  ❌ Authentication is invalid (redirected to login)")
+                return False
+
+        except Exception as e:
+            print(f"  ❌ Validation failed: {e}")
+            return False
+
+        finally:
+            if context:
+                try:
+                    context.close()
+                except Exception:
+                    pass
+            if playwright:
+                try:
+                    playwright.stop()
+                except Exception:
+                    pass
+
+
+def main():
+    """Command-line interface for authentication management"""
+    parser = argparse.ArgumentParser(description='Manage NotebookLM authentication')
+
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+
+    # Setup command
+    setup_parser = subparsers.add_parser('setup', help='Setup authentication')
+    setup_parser.add_argument('--headless', action='store_true', help='Run in headless mode')
+    setup_parser.add_argument('--timeout', type=float, default=10, help='Login timeout in minutes (default: 10)')
+
+    # Status command
+    subparsers.add_parser('status', help='Check authentication status')
+
+    # Validate command
+    subparsers.add_parser('validate', help='Validate authentication')
+
+    # Clear command
+    subparsers.add_parser('clear', help='Clear authentication')
+
+    # Re-auth command
+    reauth_parser = subparsers.add_parser('reauth', help='Re-authenticate (clear + setup)')
+    reauth_parser.add_argument('--timeout', type=float, default=10, help='Login timeout in minutes (default: 10)')
+
+    args = parser.parse_args()
+
+    # Initialize manager
+    auth = AuthManager()
+
+    # Execute command
+    if args.command == 'setup':
+        if auth.setup_auth(headless=args.headless, timeout_minutes=args.timeout):
+            print("\n✅ Authentication setup complete!")
+            print("You can now use ask_question.py to query NotebookLM")
+        else:
+            print("\n❌ Authentication setup failed")
+            exit(1)
+
+    elif args.command == 'status':
+        info = auth.get_auth_info()
+        print("\n🔐 Authentication Status:")
+        print(f"  Authenticated: {'Yes' if info['authenticated'] else 'No'}")
+        if info.get('state_age_hours'):
+            print(f"  State age: {info['state_age_hours']:.1f} hours")
+        if info.get('authenticated_at_iso'):
+            print(f"  Last auth: {info['authenticated_at_iso']}")
+        print(f"  State file: {info['state_file']}")
+
+    elif args.command == 'validate':
+        if auth.validate_auth():
+            print("Authentication is valid and working")
+        else:
+            print("Authentication is invalid or expired")
+            print("Run: auth_manager.py setup")
+
+    elif args.command == 'clear':
+        if auth.clear_auth():
+            print("Authentication cleared")
+
+    elif args.command == 'reauth':
+        if auth.re_auth(timeout_minutes=args.timeout):
+            print("\n✅ Re-authentication complete!")
+        else:
+            print("\n❌ Re-authentication failed")
+            exit(1)
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()