jleechanorg-pr-automation 0.1.1__py3-none-any.whl → 0.2.45__py3-none-any.whl

jleechanorg_pr_automation/openai_automation/debug_page_content.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+Debug script to check what's actually on the Codex page when connected via CDP.
+"""
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+from jleechanorg_pr_automation.openai_automation.codex_github_mentions import (
+    CodexGitHubMentionsAutomation,
+)
+
+
+async def debug_page():
+    """Connect to Chrome and inspect the actual page content."""
+    automation = CodexGitHubMentionsAutomation(cdp_url="http://127.0.0.1:9222", all_tasks=True)
+
+    # Connect to existing browser
+    if not await automation.connect_to_existing_browser():
+        print("❌ Failed to connect")
+        return
+
+    # Navigate to Codex
+    await automation.navigate_to_codex()
+
+    # Wait extra time for dynamic content
+    print("\n⏳ Waiting 10 seconds for page to fully load...")
+    await asyncio.sleep(10)
+
+    # Get page title
+    title = await automation.page.title()
+    print(f"\n📄 Page title: {title}")
+
+    # Get current URL
+    url = automation.page.url
+    print(f"🔗 Current URL: {url}")
+
+    # Try multiple selectors
+    print("\n🔍 Testing different selectors:")
+
+    selectors = [
+        'a[href*="/codex/"]',
+        'a:has-text("GitHub Mention:")',
+        'a[href^="https://chatgpt.com/codex/"]',
+        '[role="link"]',
+        'a',
+        'div[role="article"]',
+        'article',
+    ]
+
+    for selector in selectors:
+        try:
+            elements = await automation.page.locator(selector).all()
+            print(f"  {selector}: {len(elements)} elements")
+            if 0 < len(elements) < 20:
+                for i, elem in enumerate(elements[:3]):
+                    try:
+                        text = await elem.text_content()
+                        preview = text[:80] if text else "(no text)"
+                        print(f"    [{i}]: {preview}")
+                    except Exception as inner_err:
+                        print(f"    [{i}]: error reading text_content: {inner_err!r}")
+        except Exception as e:
+            print(f"  {selector}: Error - {e}")
+
+    # Get page HTML (first 2000 chars)
+    html = await automation.page.content()
+    print(f"\n📝 Page HTML (first 2000 chars):")
+    print(html[:2000])
+
+    # Take screenshot using a secure temp file
+    base_dir = Path("/tmp/automate_codex_update")
+    base_dir.mkdir(parents=True, exist_ok=True)
+    fd, screenshot_path = tempfile.mkstemp(prefix="debug_screenshot_", suffix=".png", dir=str(base_dir))
+    await automation.page.screenshot(path=screenshot_path)
+    try:
+        os.close(fd)
+    except OSError:
+        # Debug script: safe to ignore close errors on temp fd
+        pass
+    print(f"\n📸 Screenshot saved to: {screenshot_path}")
+
+    await automation.cleanup()
+
+
+if __name__ == "__main__":
+    asyncio.run(debug_page())

jleechanorg_pr_automation/openai_automation/oracle_cli.py

@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""
+Oracle CLI - Ask GPT-5 Pro questions via browser automation
+
+This tool opens a browser (reusing existing session), navigates to ChatGPT,
+and sends a question to GPT-5 Pro (or GPT-4 Pro), then retrieves the answer.
+
+Inspired by the existing Oracle tool's browser-based approach for querying
+AI models without needing API keys.
+
+Usage:
+    # Ask a question
+    oracle "What is the capital of France?"
+
+    # With specific model
+    oracle "Explain quantum computing" --model gpt-5-pro
+
+    # Interactive mode
+    oracle --interactive
+
+    # Use existing browser (requires start_chrome_debug.sh)
+    oracle "Question" --use-existing-browser
+"""
+
+import argparse
+import asyncio
+import traceback
+from typing import Optional
+
+from playwright.async_api import (
+    Browser,
+    Page,
+    Playwright,
+    TimeoutError as PlaywrightTimeoutError,
+    async_playwright,
+)
+
+
+class OracleCLI:
+    """CLI tool to ask GPT-5 Pro questions via browser automation."""
+
+    def __init__(
+        self,
+        cdp_url: Optional[str] = None,
+        model: str = "gpt-5-pro",
+        timeout: int = 60
+    ):
+        """
+        Initialize Oracle CLI.
+
+        Args:
+            cdp_url: Chrome DevTools Protocol URL (if connecting to existing browser)
+            model: Model to use (gpt-5-pro, gpt-4, etc.)
+            timeout: Timeout in seconds for response
+        """
+        self.cdp_url = cdp_url
+        self.model = model
+        self.timeout = timeout
+        self.playwright: Optional[Playwright] = None
+        self.browser: Optional[Browser] = None
+        self.page: Optional[Page] = None
+
+    async def setup(self):
+        """Set up browser connection."""
+        if self.playwright is None:
+            self.playwright = await async_playwright().start()
+
+        if self.cdp_url:
+            # Connect to existing browser
+            print(f"🔌 Connecting to existing browser at {self.cdp_url}...")
+            self.browser = await self.playwright.chromium.connect_over_cdp(self.cdp_url)
+            contexts = self.browser.contexts
+            if contexts:
+                context = contexts[0]
+                if context.pages:
+                    self.page = context.pages[0]
+                else:
+                    self.page = await context.new_page()
+            else:
+                context = await self.browser.new_context()
+                self.page = await context.new_page()
+        else:
+            # Launch new browser (visible)
+            self.browser = await self.playwright.chromium.launch(headless=False)
+            context = await self.browser.new_context()
+            self.page = await context.new_page()
+
+        print("✅ Browser ready")
+
+    async def navigate_to_chatgpt(self):
+        """Navigate to ChatGPT and ensure logged in."""
+        print("📍 Navigating to ChatGPT...")
+
+        await self.page.goto("https://chatgpt.com/", wait_until="networkidle")
+        await asyncio.sleep(2)
+
+        # Check if logged in
+        try:
+            await self.page.wait_for_selector(
+                'button[aria-label*="User"], [data-testid="profile-button"]',
+                timeout=5000
+            )
+            print("✅ Logged in to ChatGPT")
+        except PlaywrightTimeoutError:
+            print("⚠️  Not logged in - please log in manually")
+            print("   Waiting 30 seconds for you to log in...")
+            await asyncio.sleep(30)
+        except Exception as login_error:
+            print(f"⚠️  Unexpected login check error: {login_error}")
+            await asyncio.sleep(5)
+
+    async def select_model(self):
+        """Select the specified model (GPT-5 Pro, GPT-4, etc.)."""
+        print(f"🤖 Selecting model: {self.model}...")
+
+        try:
+            # Look for model selector (adjust based on actual UI)
+            model_selector = await self.page.wait_for_selector(
+                'button:has-text("GPT-"), [data-testid="model-selector"]',
+                timeout=5000
+            )
+
+            await model_selector.click()
+            await asyncio.sleep(1)
+
+            # Click on desired model
+            model_option = await self.page.wait_for_selector(
+                f'text="{self.model}"',
+                timeout=3000
+            )
+
+            await model_option.click()
+            await asyncio.sleep(1)
+
+            print(f"✅ Selected {self.model}")
+
+        except Exception as e:
+            print(f"⚠️  Could not select model: {e}")
+            print("   Using default model")
+
+    async def ask_question(self, question: str) -> str:
+        """
+        Ask a question and get the response.
+
+        Args:
+            question: The question to ask
+
+        Returns:
+            The AI's response text
+        """
+        print(f"\n❓ Question: {question}")
+        print("=" * 60)
+
+        try:
+            # Find the input textarea
+            input_box = await self.page.wait_for_selector(
+                'textarea[placeholder*="Message"], textarea[data-id="message-input"]',
+                timeout=10000
+            )
+
+            # Type the question
+            await input_box.click()
+            await input_box.fill(question)
+            await asyncio.sleep(0.5)
+
+            # Find and click send button
+            send_button = await self.page.wait_for_selector(
+                'button[data-testid="send-button"], button:has-text("Send")',
+                timeout=5000
+            )
+
+            await send_button.click()
+
+            # Wait for response
+            print("⏳ Waiting for response...")
+
+            # Wait for response to appear and complete
+            # This is tricky - ChatGPT streams responses
+            # We need to wait for the stop button to disappear (indicating response is complete)
+            try:
+                # Wait for stop button to appear (response started)
+                await self.page.wait_for_selector(
+                    'button:has-text("Stop"), [data-testid="stop-button"]',
+                    timeout=10000
+                )
+
+                # Wait for stop button to disappear (response completed)
+                await self.page.wait_for_selector(
+                    'button:has-text("Stop"), [data-testid="stop-button"]',
+                    state="hidden",
+                    timeout=self.timeout * 1000
+                )
+
+                await asyncio.sleep(1)
+
+            except Exception as e:
+                print(f"⚠️  Response detection issue: {e}")
+                # Fallback: just wait a bit
+                await asyncio.sleep(10)
+
+            # Extract the response
+            # Find the last message (should be the AI's response)
+            messages = await self.page.locator('[data-message-author-role="assistant"]').all()
+
+            if messages:
+                response = await messages[-1].text_content()
+                response_text = (response or "").strip()
+                return response_text or "❌ Empty response received"
+            else:
+                return "❌ Could not extract response"
+
+        except Exception as e:
+            print(f"❌ Error asking question: {e}")
+            traceback.print_exc()
+            return f"Error: {e}"
+
+    async def interactive_mode(self):
+        """Run in interactive mode for multiple questions."""
+        print("\n🎙️  Oracle Interactive Mode")
+        print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+        print("Type your questions (or 'exit' to quit)")
+        print("")
+
+        while True:
+            try:
+                question = input("\n❓ Your question: ").strip()
+
+                if not question:
+                    continue
+
+                if question.lower() in ['exit', 'quit', 'q']:
+                    print("👋 Goodbye!")
+                    break
+
+                response = await self.ask_question(question)
+                print(f"\n💡 Answer:\n{response}")
+                print("\n" + "━" * 60)
+
+            except KeyboardInterrupt:
+                print("\n\n👋 Interrupted by user")
+                break
+
+    async def run(self, question: Optional[str] = None, interactive: bool = False):
+        """
+        Main workflow.
+
+        Args:
+            question: Single question to ask (if not interactive)
+            interactive: Run in interactive mode
+        """
+        try:
+            await self.setup()
+            await self.navigate_to_chatgpt()
+            await self.select_model()
+
+            if interactive:
+                await self.interactive_mode()
+            elif question:
+                response = await self.ask_question(question)
+                print(f"\n💡 Answer:\n{response}")
+                return response
+            else:
+                print("❌ No question provided and not in interactive mode")
+                return None
+
+        except KeyboardInterrupt:
+            print("\n\n⚠️  Interrupted by user")
+            return None
+
+        except Exception as e:
+            print(f"\n❌ Oracle failed: {e}")
+            traceback.print_exc()
+            return None
+
+        finally:
+            if self.browser and not self.cdp_url:
+                # Only close if we launched it (not using existing browser)
+                await self.browser.close()
+            if self.playwright:
+                await self.playwright.stop()
+                self.playwright = None
+
+
+async def main():
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Ask GPT-5 Pro questions via browser automation",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Ask a single question
+    oracle "What is the meaning of life?"
+
+    # Interactive mode
+    oracle --interactive
+
+    # Use specific model
+    oracle "Explain AI" --model gpt-4
+
+    # Connect to existing browser
+    oracle "Question" --use-existing-browser --cdp-port 9222
+        """
+    )
+
+    parser.add_argument(
+        "question",
+        nargs="?",
+        help="Question to ask (optional if using --interactive)"
+    )
+
+    parser.add_argument(
+        "-i", "--interactive",
+        action="store_true",
+        help="Run in interactive mode for multiple questions"
+    )
+
+    parser.add_argument(
+        "--model",
+        default="gpt-5-pro",
+        help="Model to use (default: gpt-5-pro)"
+    )
+
+    parser.add_argument(
+        "--use-existing-browser",
+        action="store_true",
+        help="Connect to existing Chrome instance (requires start_chrome_debug.sh)"
+    )
+
+    parser.add_argument(
+        "--cdp-port",
+        type=int,
+        default=9222,
+        help="CDP port if using existing browser (default: 9222)"
+    )
+
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=60,
+        help="Timeout in seconds for response (default: 60)"
+    )
+
+    args = parser.parse_args()
+
+    # Validate inputs
+    if not args.question and not args.interactive:
+        parser.error("Must provide either a question or use --interactive mode")
+
+    # Build CDP URL if using existing browser
+    cdp_url = f"http://localhost:{args.cdp_port}" if args.use_existing_browser else None
+
+    # Create Oracle instance
+    oracle = OracleCLI(
+        cdp_url=cdp_url,
+        model=args.model,
+        timeout=args.timeout
+    )
+
+    # Run
+    await oracle.run(question=args.question, interactive=args.interactive)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

jleechanorg_pr_automation/openai_automation/test_auth_restoration.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""
+Unit tests for authentication state restoration in CodexGitHubMentionsAutomation.
+Focuses on cookie validation, localStorage restoration, and error handling.
+"""
+
+import json
+from unittest.mock import AsyncMock, Mock, patch
+import pytest
+from playwright.async_api import TimeoutError as PlaywrightTimeoutError
+from jleechanorg_pr_automation.openai_automation.codex_github_mentions import (
+    CodexGitHubMentionsAutomation,
+    AUTH_STATE_PATH,
+)
+
+@pytest.fixture
+def automation():
+    """Create automation instance with mocked browser/context/page."""
+    auto = CodexGitHubMentionsAutomation()
+    auto.context = AsyncMock()
+    
+    # Setup page mock
+    page_mock = AsyncMock()
+    # is_closed is synchronous in Playwright
+    page_mock.is_closed = Mock(return_value=False)
+    page_mock.url = "https://chatgpt.com/c/123"
+    
+    auto.page = page_mock
+    return auto
+
+@pytest.mark.asyncio
+async def test_auth_restoration_cookies_and_localstorage(automation):
+    """Test full restoration of cookies and localStorage from valid auth state."""
+    
+    mock_state = {
+        "cookies": [
+            {
+                "name": "session_token", 
+                "value": "xyz", 
+                "domain": ".chatgpt.com", 
+                "path": "/"
+            }
+        ],
+        "origins": [
+            {
+                "origin": "https://chatgpt.com",
+                "localStorage": [
+                    {"name": "theme", "value": "dark"},
+                    {"name": "feature_flags", "value": "true"}
+                ]
+            }
+        ]
+    }
+    
+    # Mock file existence and read
+    with patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions.AUTH_STATE_PATH") as mock_path, \
+         patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions._ensure_auth_state_permissions") as mock_perms:
+        
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = json.dumps(mock_state)
+        mock_path.__str__.return_value = "/tmp/fake_path"
+        
+        # Configure wait_for_selector to fail first, then succeed
+        automation.page.wait_for_selector.side_effect = [
+            PlaywrightTimeoutError("Not logged in"),
+            True
+        ]
+        
+        result = await automation.ensure_openai_login()
+        
+        # Verify permissions check
+        mock_perms.assert_called_once_with(mock_path)
+        
+        # Verify cookie injection
+        automation.context.add_cookies.assert_awaited_once_with(mock_state["cookies"])
+        
+        # Verify localStorage injection via page.evaluate
+        assert automation.page.evaluate.call_count == 2
+        
+        # Verify calls contain the correct keys/values
+        call_args = automation.page.evaluate.await_args_list
+        # Note: calls might be in any order if list iteration order varies, but list is ordered here
+        assert 'setItem("theme", "dark")' in call_args[0][0][0]
+        assert 'setItem("feature_flags", "true")' in call_args[1][0][0]
+        
+        assert result is True
+
+@pytest.mark.asyncio
+async def test_auth_restoration_origin_mismatch(automation):
+    """Test that localStorage is NOT injected if origin doesn't match."""
+    
+    mock_state = {
+        "cookies": [{"name": "c", "value": "v", "domain": "chatgpt.com", "path": "/"}],
+        "origins": [
+            {
+                "origin": "https://other-domain.com",
+                "localStorage": [{"name": "secret", "value": "fail"}]
+            }
+        ]
+    }
+    
+    # Page URL is chatgpt.com (from fixture), so origin shouldn't match
+    with patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions.AUTH_STATE_PATH") as mock_path, \
+         patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions._ensure_auth_state_permissions"):
+        
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = json.dumps(mock_state)
+        
+        automation.page.wait_for_selector.side_effect = [PlaywrightTimeoutError("Fail"), True]
+        
+        await automation.ensure_openai_login()
+        
+        # Should NOT call evaluate to set items
+        automation.page.evaluate.assert_not_awaited()
+
+@pytest.mark.asyncio
+async def test_auth_restoration_secure_origin_matching(automation):
+    """Test that subdomain matching prevents injection into wrong subdomains."""
+    
+    # State has origin https://chatgpt.com
+    mock_state = {
+        "cookies": [{"name": "c", "value": "v", "domain": "chatgpt.com", "path": "/"}],
+        "origins": [
+            {
+                "origin": "https://chatgpt.com",
+                "localStorage": [{"name": "key", "value": "val"}]
+            }
+        ]
+    }
+    
+    # 1. Malicious subdomain matching test
+    automation.page.url = "https://chatgpt.com.evil.com/login"
+    
+    with patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions.AUTH_STATE_PATH") as mock_path, \
+         patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions._ensure_auth_state_permissions"):
+        
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = json.dumps(mock_state)
+        
+        automation.page.wait_for_selector = AsyncMock(side_effect=[
+            PlaywrightTimeoutError("Fail"),
+            True
+        ])
+        await automation.ensure_openai_login()
+        automation.page.evaluate.assert_not_awaited()
+
+    # 2. Correct domain test
+    automation.page.url = "https://chatgpt.com/c/123"
+    
+    with patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions.AUTH_STATE_PATH") as mock_path, \
+         patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions._ensure_auth_state_permissions"):
+        
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = json.dumps(mock_state)
+        
+        # Reset mock for second run
+        automation.page.evaluate = AsyncMock()
+        automation.page.wait_for_selector = AsyncMock(side_effect=[
+            PlaywrightTimeoutError("Fail"),
+            True
+        ])
+        
+        await automation.ensure_openai_login()
+        automation.page.evaluate.assert_awaited()
+
+@pytest.mark.asyncio
+async def test_auth_restoration_cookie_validation(automation):
+    """Test validation of cookies (missing fields, incomplete data)."""
+    
+    mock_state = {
+        "cookies": [
+            {"name": "valid", "value": "1", "domain": ".com", "path": "/"}, # Valid
+            {"name": "bad1"}, # Missing value
+            {"name": "bad2", "value": "2"}, # Missing domain/path AND url
+            {"not_a_dict": True}, # Invalid type
+        ]
+    }
+    
+    with patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions.AUTH_STATE_PATH") as mock_path, \
+         patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions._ensure_auth_state_permissions"):
+        
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = json.dumps(mock_state)
+        
+        automation.page.wait_for_selector.side_effect = [PlaywrightTimeoutError("Fail"), True]
+        
+        await automation.ensure_openai_login()
+        
+        # Should only inject the one valid cookie
+        automation.context.add_cookies.assert_awaited_once()
+        call_args = automation.context.add_cookies.call_args[0][0]
+        assert len(call_args) == 1
+        assert call_args[0]["name"] == "valid"
+
+@pytest.mark.asyncio
+async def test_auth_restoration_null_cookies(automation):
+    """Test handling of 'cookies': null in JSON."""
+    
+    mock_state = {"cookies": None}
+    
+    with patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions.AUTH_STATE_PATH") as mock_path, \
+         patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions._ensure_auth_state_permissions"):
+        
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = json.dumps(mock_state)
+        
+        automation.page.wait_for_selector.side_effect = [PlaywrightTimeoutError("Fail"), True]
+        
+        await automation.ensure_openai_login()
+        
+        # Should not crash, should not call add_cookies
+        automation.context.add_cookies.assert_not_awaited()
+
+@pytest.mark.asyncio
+async def test_auth_restoration_empty_localstorage_values(automation):
+    """Test that empty string values in localStorage are preserved (not skipped)."""
+    
+    mock_state = {
+        "cookies": [{"name": "c", "value": "v", "domain": "chatgpt.com", "path": "/"}],
+        "origins": [
+            {
+                "origin": "https://chatgpt.com",
+                "localStorage": [
+                    {"name": "empty_val", "value": ""}, # Should be kept
+                    {"name": "null_val", "value": None}  # Should be skipped if logic checks for None
+                ]
+            }
+        ]
+    }
+    
+    with patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions.AUTH_STATE_PATH") as mock_path, \
+         patch("jleechanorg_pr_automation.openai_automation.codex_github_mentions._ensure_auth_state_permissions"):
+        
+        mock_path.exists.return_value = True
+        mock_path.read_text.return_value = json.dumps(mock_state)
+        
+        automation.page.wait_for_selector.side_effect = [PlaywrightTimeoutError("Fail"), True]
+        await automation.ensure_openai_login()
+        
+        # Should call evaluate for empty string value
+        # But NOT for None value (logic: if key is not None and value is not None)
+        assert automation.page.evaluate.call_count == 1
+        call_arg = automation.page.evaluate.call_args[0][0]
+        assert 'setItem("empty_val", "")' in call_arg