jleechanorg-pr-automation 0.1.0__py3-none-any.whl

jleechanorg_pr_automation/codex_branch_updater.py

@@ -0,0 +1,272 @@
+"""Playwright automation for managing Codex tasks on ChatGPT."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import random
+from getpass import getpass
+from pathlib import Path
+from typing import Dict, Tuple
+
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    Error as PlaywrightError,
+    Page,
+    TimeoutError as PlaywrightTimeoutError,
+    async_playwright,
+)
+
+CHATGPT_CODEX_URL = "https://chatgpt.com/codex"
+CREDENTIALS_PATH = Path.home() / ".chatgpt_codex_credentials.json"
+AUTH_STATE_PATH = Path.home() / ".chatgpt_codex_auth_state.json"
+TASK_CARD_SELECTOR = "[data-testid=\"codex-task-card\"]"
+UPDATE_BRANCH_BUTTON_SELECTOR = "button:has-text(\"Update Branch\")"
+TASK_TITLE_SELECTOR = "[data-testid=\"codex-task-title\"]"
+
+
+def _save_credentials(credentials: Dict[str, str]) -> None:
+    """Persist credentials to disk with restrictive permissions."""
+
+    CREDENTIALS_PATH.write_text(json.dumps(credentials, indent=2))
+    os.chmod(CREDENTIALS_PATH, 0o600)
+
+
+def _load_credentials() -> Dict[str, str] | None:
+    """Return stored credentials if available and well formed."""
+
+    if not CREDENTIALS_PATH.exists():
+        return None
+
+    try:
+        data = json.loads(CREDENTIALS_PATH.read_text())
+    except json.JSONDecodeError:
+        return None
+
+    email = data.get("email")
+    password = data.get("password")
+    if not email or not password:
+        return None
+
+    return {"email": email, "password": password}
+
+
+def prompt_for_credentials() -> Dict[str, str]:
+    """Prompt the user for credentials and persist them."""
+
+    print("🔐 ChatGPT Codex credentials not found. They will be stored locally at")
+    print(f"    {CREDENTIALS_PATH}")
+    email = input("ChatGPT email: ").strip()
+    password = getpass("ChatGPT password: ")
+
+    credentials = {"email": email, "password": password}
+    _save_credentials(credentials)
+    print("✅ Credentials saved locally (chmod 600).")
+    return credentials
+
+
+def get_credentials() -> Dict[str, str]:
+    """Load stored credentials or prompt the user."""
+
+    credentials = _load_credentials()
+    if credentials is None:
+        credentials = prompt_for_credentials()
+    return credentials
+
+
+async def ensure_logged_in(page: Page, credentials: Dict[str, str] | None = None) -> None:
+    """Log into ChatGPT Codex if required."""
+
+    await page.goto(CHATGPT_CODEX_URL, wait_until="domcontentloaded")
+
+    if await is_task_list_visible(page):
+        return
+
+    if credentials is None:
+        credentials = get_credentials()
+
+    login_trigger = page.get_by_role("link", name="Log in")
+    if await login_trigger.count() == 0:
+        login_trigger = page.get_by_role("button", name="Log in")
+    if await login_trigger.count():
+        await login_trigger.first().click()
+
+    await _complete_login_flow(page, credentials)
+
+
+async def _complete_login_flow(page: Page, credentials: Dict[str, str]) -> None:
+    """Fill in the login flow using the provided credentials."""
+
+    email_field = page.locator("input[type='email']")
+    await email_field.first().wait_for(timeout=30000)
+    await email_field.first().fill(credentials["email"])
+
+    next_button = page.get_by_role("button", name="Continue")
+    if await next_button.count():
+        await next_button.first().click()
+    else:
+        await page.keyboard.press("Enter")
+
+    password_field = page.locator("input[type='password']")
+    await password_field.first().wait_for(timeout=30000)
+    await password_field.first().fill(credentials["password"])
+
+    signin_button = page.get_by_role("button", name="Continue")
+    if await signin_button.count() == 0:
+        signin_button = page.get_by_role("button", name="Sign in")
+    if await signin_button.count() == 0:
+        signin_button = page.get_by_role("button", name="Log in")
+
+    if await signin_button.count():
+        await signin_button.first().click()
+    else:
+        await page.keyboard.press("Enter")
+
+    await page.wait_for_url("**/codex**", timeout=60000)
+    await wait_for_task_list(page)
+
+
+async def is_task_list_visible(page: Page) -> bool:
+    """Return True if the Codex task list is visible."""
+
+    task_cards = page.locator(TASK_CARD_SELECTOR)
+    try:
+        await task_cards.first().wait_for(timeout=5000)
+    except PlaywrightTimeoutError:
+        return False
+    return await task_cards.count() > 0
+
+
+async def wait_for_task_list(page: Page) -> None:
+    """Wait until task cards are available."""
+
+    await page.wait_for_selector(TASK_CARD_SELECTOR, timeout=60000)
+
+
+async def collect_task_metadata(page: Page, index: int) -> Tuple[str, str]:
+    """Return the title and status text for a given task card."""
+
+    task_card = page.locator(TASK_CARD_SELECTOR).nth(index)
+    title_locator = task_card.locator(TASK_TITLE_SELECTOR)
+    title = await title_locator.inner_text() if await title_locator.count() else f"Task #{index + 1}"
+    status_locator = task_card.locator("[data-testid='codex-task-status']")
+    status = await status_locator.inner_text() if await status_locator.count() else ""
+    return title.strip(), status.strip()
+
+
+async def process_tasks(page: Page) -> None:
+    """Iterate through all Codex tasks and click Update Branch when present."""
+
+    processed_indices: set[int] = set()
+
+    while True:
+        task_cards = page.locator(TASK_CARD_SELECTOR)
+        total_tasks = await task_cards.count()
+        if total_tasks == 0:
+            print("ℹ️  No tasks detected on Codex dashboard.")
+            return
+
+        pending_indices = [idx for idx in range(total_tasks) if idx not in processed_indices]
+        if not pending_indices:
+            print("🏁 Completed processing available tasks.")
+            return
+
+        for index in pending_indices:
+            task_card = task_cards.nth(index)
+            await task_card.scroll_into_view_if_needed()
+
+            title, status = await collect_task_metadata(page, index)
+            print(f"🔍 Inspecting {title} ({status or 'no status'})")
+
+            update_button = task_card.locator(UPDATE_BRANCH_BUTTON_SELECTOR)
+            button_count = await update_button.count()
+            if button_count:
+                try:
+                    await update_button.first().click()
+                    print("✅ Clicked Update Branch directly from task card.")
+                    processed_indices.add(index)
+                    await _post_action_delay(page)
+                    continue
+                except PlaywrightError as exc:
+                    print(f"⚠️  Failed to click Update Branch on card: {exc}")
+
+            await task_card.click()
+            await page.wait_for_timeout(1000)
+
+            modal_update_button = page.locator(UPDATE_BRANCH_BUTTON_SELECTOR)
+            try:
+                await modal_update_button.first().wait_for(timeout=5000)
+                await modal_update_button.first().click()
+                print("✅ Clicked Update Branch inside task detail.")
+            except PlaywrightTimeoutError:
+                print("➡️  No Update Branch button found for this task. Skipping.")
+            except PlaywrightError as exc:
+                print(f"⚠️  Error clicking Update Branch in detail view: {exc}")
+
+            await _close_task_detail(page)
+            processed_indices.add(index)
+            await _post_action_delay(page)
+
+
+async def _close_task_detail(page: Page) -> None:
+    """Attempt to close a task detail view or navigate back."""
+
+    for name in ("Close", "Back", "Done"):
+        button = page.get_by_role("button", name=name)
+        if await button.count():
+            await button.first().click()
+            await page.wait_for_timeout(500)
+            return
+
+    try:
+        await page.go_back(wait_until="domcontentloaded")
+        await wait_for_task_list(page)
+    except PlaywrightError:
+        pass
+
+
+async def _post_action_delay(page: Page) -> None:
+    """Add a small randomized delay to appear human-like."""
+
+    delay_ms = random.randint(1000, 2500)
+    await page.wait_for_timeout(delay_ms)
+
+
+async def run() -> None:
+    """Entry point for running the Playwright automation."""
+
+    playwright = await async_playwright().start()
+    browser: Browser | None = None
+    context: BrowserContext | None = None
+    try:
+        browser = await playwright.chromium.launch(headless=False)
+        context_kwargs = {}
+        if AUTH_STATE_PATH.exists():
+            context_kwargs["storage_state"] = str(AUTH_STATE_PATH)
+        context = await browser.new_context(**context_kwargs)
+        page = await context.new_page()
+
+        await ensure_logged_in(page)
+        await wait_for_task_list(page)
+        await process_tasks(page)
+
+        await context.storage_state(path=str(AUTH_STATE_PATH))
+        print(f"💾 Authentication state saved to {AUTH_STATE_PATH}.")
+    finally:
+        if context is not None:
+            await context.close()
+        if browser is not None:
+            await browser.close()
+        await playwright.stop()
+
+
+def main() -> None:
+    """Synchronous wrapper for asyncio entry point."""
+
+    asyncio.run(run())
+
+
+if __name__ == "__main__":
+    main()

jleechanorg_pr_automation/codex_config.py

@@ -0,0 +1,57 @@
+"""Shared configuration for Codex automation workflows."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+DEFAULT_ASSISTANT_HANDLE = "coderabbitai"
+
+# Core instruction template with hardcoded AI assistant mentions
+CODEX_COMMENT_TEMPLATE = (
+    "@codex @coderabbitai @copilot @cursor [AI automation] Please make the following changes to this PR\n\n"
+    "Use your judgment to fix comments from everyone or explain why it should not be fixed. "
+    "Follow binary response protocol - every comment needs \"DONE\" or \"NOT DONE\" classification "
+    "explicitly with an explanation. Address all comments on this PR. Fix any failing tests and "
+    "resolve merge conflicts. Push any commits needed to remote so the PR is updated."
+)
+
+CODEX_COMMIT_MARKER_PREFIX = "<!-- codex-automation-commit:"
+CODEX_COMMIT_MARKER_SUFFIX = "-->"
+
+
+def normalise_handle(assistant_handle: str | None) -> str:
+    """Return a sanitized assistant handle without a leading '@'."""
+
+    if assistant_handle is None:
+        return DEFAULT_ASSISTANT_HANDLE
+
+    # Treat an empty string as "unspecified" so we fall back to the default
+    # handle rather than emitting a bare "@" mention in comments.
+    cleaned = assistant_handle.lstrip("@")
+    return cleaned or DEFAULT_ASSISTANT_HANDLE
+
+
+def build_default_comment(assistant_handle: str | None = None) -> str:
+    """Return the default Codex instruction text for the given handle."""
+
+    handle = normalise_handle(assistant_handle)
+    return CODEX_COMMENT_TEMPLATE.format(assistant_handle=handle)
+
+
+@dataclass(frozen=True)
+class CodexConfig:
+    """Convenience container for sharing Codex automation constants."""
+
+    assistant_handle: str
+    comment_text: str
+    commit_marker_prefix: str = CODEX_COMMIT_MARKER_PREFIX
+    commit_marker_suffix: str = CODEX_COMMIT_MARKER_SUFFIX
+
+    @classmethod
+    def from_env(cls, assistant_handle: str | None) -> "CodexConfig":
+        handle = normalise_handle(assistant_handle)
+        return cls(
+            assistant_handle=handle,
+            comment_text=build_default_comment(handle),
+        )