@caddis/cli 0.1.0 → 0.2.0

package/bundles/antigravity-plugin-extras/skills/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/bundles/antigravity-plugin-extras/skills/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()

package/bundles/antigravity-plugin-extras/skills/notebooklm/scripts/config.py

@@ -0,0 +1,44 @@
+"""
+Configuration for NotebookLM Skill
+Centralizes constants, selectors, and paths
+"""
+
+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',  # Patches navigator.webdriver
+    '--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