@techwavedev/agi-agent-kit 1.1.7 → 1.2.7

package/templates/skills/knowledge/notebooklm-rag/scripts/auth_manager.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""
+Authentication Manager for NotebookLM RAG Skill
+Handles Google login and browser state persistence
+Adapted from PleasePrompto/notebooklm-skill (MIT License)
+
+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"""
+        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
+
+        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()
+
+            context = BrowserFactory.launch_persistent_context(
+                playwright,
+                headless=headless
+            )
+
+            page = context.new_page()
+            page.goto("https://notebooklm.google.com", wait_until="domcontentloaded")
+
+            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
+
+            print("\n  ⏳ Please log in to your Google account...")
+            print(f"  ⏱️  Waiting up to {timeout_minutes} minutes for login...")
+
+            try:
+                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!")
+
+                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:
+            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:
+            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
+
+    def clear_auth(self) -> bool:
+        """Clear all authentication data"""
+        print("🗑️ Clearing authentication data...")
+
+        try:
+            if self.state_file.exists():
+                self.state_file.unlink()
+                print("  ✅ Removed browser state")
+
+            if self.auth_info_file.exists():
+                self.auth_info_file.unlink()
+                print("  ✅ Removed auth info")
+
+            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)"""
+        print("🔄 Starting re-authentication...")
+        self.clear_auth()
+        return self.setup_auth(headless, timeout_minutes)
+
+    def validate_auth(self) -> bool:
+        """Validate that stored authentication works"""
+        if not self.is_authenticated():
+            return False
+
+        print("🔍 Validating authentication...")
+
+        playwright = None
+        context = None
+
+        try:
+            playwright = sync_playwright().start()
+
+            context = BrowserFactory.launch_persistent_context(
+                playwright,
+                headless=True
+            )
+
+            page = context.new_page()
+            page.goto("https://notebooklm.google.com", wait_until="domcontentloaded", timeout=30000)
+
+            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_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)')
+
+    subparsers.add_parser('status', help='Check authentication status')
+    subparsers.add_parser('validate', help='Validate authentication')
+    subparsers.add_parser('clear', help='Clear authentication')
+
+    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()
+
+    auth = AuthManager()
+
+    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()

package/templates/skills/knowledge/notebooklm-rag/scripts/browser_utils.py

@@ -0,0 +1,101 @@
+"""
+Browser Utilities for NotebookLM RAG Skill
+Handles browser launching, stealth features, and common interactions
+Adapted from PleasePrompto/notebooklm-skill (MIT License)
+"""
+
+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.
+        """
+        context = playwright.chromium.launch_persistent_context(
+            user_data_dir=user_data_dir,
+            channel="chrome",
+            headless=headless,
+            no_viewport=True,
+            ignore_default_args=["--enable-automation"],
+            user_agent=USER_AGENT,
+            args=BROWSER_ARGS
+        )
+
+        # Cookie Workaround for Playwright bug #36139
+        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'])
+            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:
+                element = page.wait_for_selector(selector, timeout=2000)
+            except:
+                pass
+
+        if not element:
+            print(f"⚠️ Element not found for typing: {selector}")
+            return
+
+        element.click()
+
+        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
+
+        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/skills/knowledge/notebooklm-rag/scripts/cleanup_manager.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+Data Cleanup Manager for NotebookLM RAG Skill
+Handles cleaning browser data, auth state, and optionally library
+"""
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+from config import DATA_DIR, BROWSER_STATE_DIR, STATE_FILE, AUTH_INFO_FILE, LIBRARY_FILE
+
+
+def preview_cleanup(preserve_library: bool = False):
+    """Show what would be cleaned up"""
+    print("🔍 Cleanup Preview:")
+    items = []
+
+    if BROWSER_STATE_DIR.exists():
+        size = sum(f.stat().st_size for f in BROWSER_STATE_DIR.rglob('*') if f.is_file())
+        items.append(f"  Browser state: {size / 1024:.1f} KB")
+
+    if STATE_FILE.exists():
+        items.append(f"  State file: {STATE_FILE}")
+
+    if AUTH_INFO_FILE.exists():
+        items.append(f"  Auth info: {AUTH_INFO_FILE}")
+
+    if not preserve_library and LIBRARY_FILE.exists():
+        items.append(f"  Library: {LIBRARY_FILE}")
+    elif preserve_library and LIBRARY_FILE.exists():
+        items.append(f"  Library: PRESERVED ✓")
+
+    if items:
+        for item in items:
+            print(item)
+    else:
+        print("  Nothing to clean up")
+
+    return len(items) > 0
+
+
+def execute_cleanup(preserve_library: bool = False):
+    """Execute cleanup"""
+    print("🗑️ Cleaning up...")
+
+    if BROWSER_STATE_DIR.exists():
+        shutil.rmtree(BROWSER_STATE_DIR)
+        BROWSER_STATE_DIR.mkdir(parents=True, exist_ok=True)
+        print("  ✅ Cleared browser state")
+
+    if STATE_FILE.exists():
+        STATE_FILE.unlink()
+        print("  ✅ Removed state file")
+
+    if AUTH_INFO_FILE.exists():
+        AUTH_INFO_FILE.unlink()
+        print("  ✅ Removed auth info")
+
+    if not preserve_library and LIBRARY_FILE.exists():
+        LIBRARY_FILE.unlink()
+        print("  ✅ Removed library")
+    elif preserve_library:
+        print("  📚 Library preserved")
+
+    print("  ✅ Cleanup complete!")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Clean up NotebookLM RAG skill data')
+    parser.add_argument('--confirm', action='store_true', help='Execute cleanup (default: preview only)')
+    parser.add_argument('--preserve-library', action='store_true', help='Keep notebook library')
+
+    args = parser.parse_args()
+
+    if args.confirm:
+        execute_cleanup(preserve_library=args.preserve_library)
+    else:
+        has_items = preview_cleanup(preserve_library=args.preserve_library)
+        if has_items:
+            print("\nRun with --confirm to execute cleanup")
+
+
+if __name__ == "__main__":
+    main()

package/templates/skills/knowledge/notebooklm-rag/scripts/config.py

@@ -0,0 +1,45 @@
+"""
+Configuration for NotebookLM RAG Skill
+Centralizes constants, selectors, and paths
+Adapted from PleasePrompto/notebooklm-skill (MIT License)
+"""
+
+from pathlib import Path
+
+# Paths
+SKILL_DIR = Path(__file__).parent.parent
+DATA_DIR = SKILL_DIR / "data"
+BROWSER_STATE_DIR = DATA_DIR / "browser_state"
+BROWSER_PROFILE_DIR = BROWSER_STATE_DIR / "browser_profile"
+STATE_FILE = BROWSER_STATE_DIR / "state.json"
+AUTH_INFO_FILE = DATA_DIR / "auth_info.json"
+LIBRARY_FILE = DATA_DIR / "library.json"
+
+# NotebookLM Selectors
+QUERY_INPUT_SELECTORS = [
+    "textarea.query-box-input",  # Primary
+    'textarea[aria-label="Feld für Anfragen"]',  # Fallback German
+    'textarea[aria-label="Input for queries"]',  # Fallback English
+]
+
+RESPONSE_SELECTORS = [
+    ".to-user-container .message-text-content",  # Primary
+    "[data-message-author='bot']",
+    "[data-message-author='assistant']",
+]
+
+# Browser Configuration
+BROWSER_ARGS = [
+    '--disable-blink-features=AutomationControlled',
+    '--disable-dev-shm-usage',
+    '--no-sandbox',
+    '--no-first-run',
+    '--no-default-browser-check'
+]
+
+USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+
+# Timeouts
+LOGIN_TIMEOUT_MINUTES = 10
+QUERY_TIMEOUT_SECONDS = 120
+PAGE_LOAD_TIMEOUT = 30000