jleechanorg-pr-automation 0.2.41__tar.gz → 0.2.48__tar.gz

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jleechanorg-pr-automation
-Version: 0.2.41
+Version: 0.2.48
 Summary: GitHub PR automation system with safety limits and actionable counting
 Author-email: jleechan <jlee@jleechan.org>
 License-Expression: MIT

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/jleechanorg_pr_automation/jleechanorg_pr_monitor.py

@@ -778,6 +778,78 @@ class JleechanorgPRMonitor:
 
         return None
 
+    def _cleanup_pending_reviews(self, repo_full: str, pr_number: int) -> None:
+        """Delete any pending reviews for the current automation user to prevent review clutter.
+
+        This is a safety measure to clean up pending reviews that may have been left behind
+        by agents that use MCP tools (create_pending_pull_request_review) without submitting.
+        """
+        try:
+            # Extract owner and repo from repo_full
+            parts = repo_full.split("/")
+            if len(parts) != 2:
+                self.logger.warning(f"Cannot parse repo_full '{repo_full}' for pending review cleanup")
+                return
+
+            owner, repo = parts
+
+            # Fetch all reviews for the PR
+            reviews_cmd = [
+                "gh", "api",
+                f"repos/{owner}/{repo}/pulls/{pr_number}/reviews",
+                "--paginate", "-q", ".[]",
+            ]
+            result = AutomationUtils.execute_subprocess_with_timeout(
+                reviews_cmd, timeout=30, check=False
+            )
+
+            if result.returncode != 0:
+                self.logger.debug(f"Could not fetch reviews for pending cleanup: {result.stderr}")
+                return
+
+            # Parse reviews and find pending ones from automation user
+            pending_deleted = 0
+            for line in (result.stdout or "").splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    review = json.loads(line)
+                    if review.get("state") == "PENDING":
+                        user_info = review.get("user")
+                        if isinstance(user_info, dict):
+                            review_user = user_info.get("login", "")
+                        else:
+                            review_user = ""
+                        if review_user == self.automation_username:
+                            review_id = review.get("id")
+                            if review_id:
+                                delete_cmd = [
+                                    "gh", "api",
+                                    f"repos/{owner}/{repo}/pulls/{pr_number}/reviews/{review_id}",
+                                    "-X", "DELETE",
+                                ]
+                                delete_result = AutomationUtils.execute_subprocess_with_timeout(
+                                    delete_cmd, timeout=30, check=False
+                                )
+                                if delete_result.returncode == 0:
+                                    self.logger.info(
+                                        f"🧹 Deleted pending review #{review_id} from {review_user} on PR #{pr_number}"
+                                    )
+                                    pending_deleted += 1
+                                else:
+                                    self.logger.debug(
+                                        f"Could not delete pending review #{review_id}: {delete_result.stderr}"
+                                    )
+                except json.JSONDecodeError:
+                    continue
+
+            if pending_deleted > 0:
+                self.logger.info(f"✅ Cleaned up {pending_deleted} pending review(s) on PR #{pr_number}")
+
+        except Exception as exc:
+            self.logger.debug(f"Pending review cleanup failed for PR #{pr_number}: {exc}")
+            # Non-fatal - continue with the workflow
+
     def post_codex_instruction_simple(self, repository: str, pr_number: int, pr_data: Dict) -> str:
         """Post codex instruction comment to PR"""
         repo_full = self._normalize_repository_name(repository)
@@ -1003,6 +1075,16 @@ Use your judgment to fix comments from everyone or explain why it should not be
             "Goal: address all review comments with explicit action-based replies, "
             "fix failing tests, and resolve merge conflicts.\n\n"
             f"CLI chain: {agent_cli}. Start immediately.\n\n"
+            "⚠️ CRITICAL - REVIEW COMMENT REPLY API (MUST READ):\n"
+            "   To reply to inline review comments WITHOUT starting a pending review, use ONLY:\n"
+            f"   `gh api /repos/{repository}/pulls/{pr_number}/comments -f body='...' -F in_reply_to={{comment_id}}`\n"
+            "   This `/comments` endpoint with `in_reply_to` parameter creates a threaded reply WITHOUT starting a review.\n"
+            "   ⚠️ IMPORTANT: Use `-f` for body (string) and `-F` for in_reply_to (numeric comment ID).\n\n"
+            "   ❌ NEVER USE these (they create pending reviews that clutter the PR):\n"
+            "   - `create_pending_pull_request_review` MCP tool\n"
+            "   - `add_comment_to_pending_review` MCP tool\n"
+            "   - `POST /repos/.../pulls/.../reviews` endpoint\n"
+            "   - Any GitHub review workflow that requires 'submit'\n\n"
             "Steps:\n"
             f"1) gh pr checkout {pr_number}\n\n"
             "2) Fetch ALL PR feedback sources (pagination-safe) using correct GitHub API endpoints:\n"
@@ -1019,9 +1101,9 @@ Use your judgment to fix comments from everyone or explain why it should not be
             "   - **DEFERRED**: Created issue for future work → include issue URL and reason\n"
             "   - **ACKNOWLEDGED**: Noted but not actionable → include explanation\n"
             "   - **NOT DONE**: Cannot implement → include specific technical reason\n\n"
-            "   **Reply Methods**:\n"
-            f"   - Inline review comments: `gh api /repos/{repository}/pulls/{pr_number}/comments/{{comment_id}}/replies -f body='[Response text]'`\n"
-            f"   - Issue/PR comments: `gh pr comment {pr_number} --body '[Response text]'`\n"
+            "   **Reply Methods (ONLY use these - no pending reviews!):**\n"
+            f"   - Inline review comments: `gh api /repos/{repository}/pulls/{pr_number}/comments -f body='[Response]' -F in_reply_to={{comment_id}}`\n"
+            f"   - Issue/PR comments: `gh pr comment {pr_number} --body '[Response]'`\n"
             "   - Do NOT post mega-comments consolidating multiple responses; reply individually to each comment.\n\n"
             "4) Run tests and fix failures (block completion on critical/blocking test failures)\n\n"
             "5) Resolve merge conflicts (prefer merge over rebase)\n\n"
@@ -1451,13 +1533,6 @@ Use your judgment to fix comments from everyone or explain why it should not be
         if not branch:
             branch = f"pr-{pr_number}"
 
-        if model and "claude" not in agent_cli.lower():
-            self.logger.warning(
-                "⚠️ Model '%s' specified but agent CLI is '%s'. Model parameter is only supported for Claude.",
-                model,
-                agent_cli,
-            )
-
         head_sha = pr_data.get("headRefOid")
         task_description = self._build_fix_comment_prompt_body(
             repo_full,
@@ -1541,6 +1616,9 @@ Use your judgment to fix comments from everyone or explain why it should not be
             self._record_processed_pr(repo_name, branch_name, pr_number, head_sha)
             return "skipped"
 
+        # Cleanup any pending reviews left behind by previous automation runs
+        self._cleanup_pending_reviews(repo_full, pr_number)
+
         if not self.dispatch_fix_comment_agent(repo_full, pr_number, pr_data, agent_cli=agent_cli, model=model):
             return "failed"
 
@@ -1609,6 +1687,9 @@ Use your judgment to fix comments from everyone or explain why it should not be
             )
             return "skipped"
 
+        # Cleanup any pending reviews left behind by previous automation runs
+        self._cleanup_pending_reviews(repo_full, pr_number)
+
         # Dispatch agent for fixpr
         try:
             base_dir = ensure_base_clone(repo_full)
@@ -2146,8 +2227,10 @@ Use your judgment to fix comments from everyone or explain why it should not be
         repo_full = self._normalize_repository_name(repository)
         self.logger.info(f"🎯 Processing target PR: {repo_full} #{pr_number}")
 
-        # Check global automation limits
-        if not self.safety_manager.can_start_global_run():
+        # Check global automation limits (fixpr uses per-PR limits only)
+        # Note: fixpr workflow bypasses global limit check - it uses per-PR fixpr_limit instead
+        # This allows fixpr to process PRs independently based on per-PR comment counts
+        if not fixpr and not self.safety_manager.can_start_global_run():
             self.logger.warning("🚫 Global automation limit reached - cannot process target PR")
             return False
 
@@ -2268,7 +2351,9 @@ Use your judgment to fix comments from everyone or explain why it should not be
         mode_label = "fix-comment" if fix_comment else ("fixpr" if fixpr else "comment")
         self.logger.info("🚀 Starting jleechanorg PR monitoring cycle (%s mode)", mode_label)
 
-        if not self.safety_manager.can_start_global_run():
+        # FixPR workflow uses per-PR limits only, not global limit
+        # Other workflows (fix-comment, pr_automation) still check global limit
+        if not fixpr and not self.safety_manager.can_start_global_run():
             current_runs = self.safety_manager.get_global_runs()
             self.logger.warning(
                 "🚫 Global automation limit reached %s/%s",
@@ -2712,7 +2797,7 @@ def main():
         "--model",
         type=str,
         default=None,
-        help="Model to use for Claude CLI (e.g., sonnet, opus, haiku). Only applies when using claude.",
+        help="Model to use for agent CLI. Examples: sonnet/opus/haiku (Claude), gemini-3-pro-preview/gemini-3-auto (Gemini), composer-1 (Cursor). If not specified, CLI-specific defaults are used.",
     )
     parser.add_argument("--list-eligible", action="store_true",
                         help="Dry-run listing of PRs eligible for fixpr (conflicts/failing checks)")

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/jleechanorg_pr_automation/openai_automation/codex_github_mentions.py

@@ -21,6 +21,7 @@ Usage:
 
 import argparse
 import asyncio
+import json
 import logging
 import sys
 import time
@@ -28,6 +29,7 @@ import traceback
 from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional, Set
+from urllib.parse import urlparse
 
 from playwright.async_api import (
     Browser,
@@ -283,6 +285,149 @@ class CodexGitHubMentionsAutomation:
 
             return True
         except PlaywrightTimeoutError:
+            # If not logged in, try to restore from auth state file first (even in CDP mode)
+            if AUTH_STATE_PATH.exists():
+                print(f"🔄 Not logged in. Attempting to restore auth state from {AUTH_STATE_PATH}...")
+                try:
+                    _ensure_auth_state_permissions(AUTH_STATE_PATH)
+                    state_content = AUTH_STATE_PATH.read_text()
+                    state_data = json.loads(state_content)
+                    
+                    cookies = state_data.get("cookies")
+                    if isinstance(cookies, list):
+                        valid_cookies = []
+                        # Required fields for Playwright add_cookies
+                        # Must have name, value AND (url OR (domain AND path))
+                        required_fields = {"name", "value"}
+                        domain_fields = {"domain", "path"}
+                        
+                        for cookie in cookies:
+                            if not isinstance(cookie, dict):
+                                logger.warning("Skipping non-dict cookie entry")
+                                continue
+                            
+                            # Check basic fields
+                            if not required_fields.issubset(cookie.keys()):
+                                cookie_name = cookie.get("name", "<unknown>")
+                                logger.warning(
+                                    "Skipping malformed cookie '%s' missing required fields %s",
+                                    cookie_name,
+                                    required_fields,
+                                )
+                                continue
+                                
+                            # Check domain/path vs url constraint
+                            has_url = "url" in cookie
+                            has_domain_and_path = domain_fields.issubset(cookie.keys())
+                            
+                            if not (has_url or has_domain_and_path):
+                                cookie_name = cookie.get("name", "<unknown>")
+                                logger.warning(
+                                    "Skipping cookie '%s' missing either 'url' or both 'domain' and 'path'",
+                                    cookie_name,
+                                )
+                                continue
+                                
+                            valid_cookies.append(cookie)
+                        
+                        if valid_cookies:
+                            await self.context.add_cookies(valid_cookies)
+                            print("✅ Injected cookies from auth state file")
+                            logger.info(
+                                "Injected %d cookies from auth state file %s",
+                                len(valid_cookies),
+                                AUTH_STATE_PATH,
+                            )
+                            
+                            # Restore localStorage from origins
+                            origins = state_data.get("origins", [])
+                            if origins:
+                                try:
+                                    current_url = self.page.url
+                                    current_parsed = urlparse(current_url)
+                                    injected_origins = 0
+                                    
+                                    for origin_data in origins:
+                                        origin = origin_data.get("origin")
+                                        if not origin:
+                                            continue
+                                            
+                                        # Use exact origin matching (scheme + netloc)
+                                        origin_parsed = urlparse(origin)
+                                        origin_matches = (
+                                            current_parsed.scheme == origin_parsed.scheme
+                                            and current_parsed.netloc == origin_parsed.netloc
+                                        )
+                                        
+                                        if origin_matches:
+                                            logger.info(f"Restoring localStorage for origin {origin}")
+                                            storage_items = origin_data.get("localStorage", [])
+                                            items_injected = 0
+                                            if storage_items:
+                                                for item in storage_items:
+                                                    key = item.get("name")
+                                                    value = item.get("value")
+                                                    # Allow empty strings as valid values (use None check)
+                                                    if key is not None and value is not None:
+                                                        await self.page.evaluate(
+                                                            f"window.localStorage.setItem({json.dumps(key)}, {json.dumps(value)})"
+                                                        )
+                                                        items_injected += 1
+                                            if items_injected > 0:
+                                                injected_origins += 1
+                                    
+                                    if injected_origins > 0:
+                                        print(f"✅ Injected localStorage for {injected_origins} origin(s)")
+                                        logger.info(f"Injected localStorage for {injected_origins} origin(s)")
+                                except Exception as storage_err:
+                                    logger.warning(f"Failed to restore localStorage: {storage_err}")
+                                    print(f"⚠️  Failed to restore localStorage: {storage_err}")
+
+                            # Refresh page to apply cookies and storage
+                            await self.page.reload(wait_until="domcontentloaded")
+                            await asyncio.sleep(3)
+                            
+                            # Check login again
+                            try:
+                                await self.page.wait_for_selector(
+                                    'button[aria-label*="User"], [data-testid="profile-button"]',
+                                    timeout=5000,
+                                )
+                                print("✅ Successfully restored session from auth state")
+                                return True
+                            except PlaywrightTimeoutError:
+                                print("⚠️  Session restore failed - cookies might be expired")
+                        else:
+                            print("⚠️  No valid cookies found in auth state file")
+                            logger.warning(
+                                "No valid cookies found in auth state file %s; skipping cookie injection",
+                                AUTH_STATE_PATH,
+                            )
+                    else:
+                        if "cookies" not in state_data:
+                            print("⚠️  No 'cookies' key found in auth state file")
+                            logger.warning(
+                                "Auth state file %s has no 'cookies' key",
+                                AUTH_STATE_PATH,
+                            )
+                        elif cookies is None:
+                            print("⚠️  Cookies are null in auth state file")
+                            logger.warning(
+                                "Auth state file %s has null 'cookies' value",
+                                AUTH_STATE_PATH,
+                            )
+                        else:
+                            print("⚠️  Invalid cookies format in auth state file (expected list)")
+                            logger.warning(
+                                "Invalid cookies format in auth state file %s: expected list, got %s",
+                                AUTH_STATE_PATH,
+                                type(cookies).__name__,
+                            )
+
+                except Exception as restore_err:
+                    logger.exception("Failed to restore auth state from %s", AUTH_STATE_PATH)
+                    print(f"⚠️  Failed to restore auth state: {restore_err!r}")
+
             try:
                 await self.page.wait_for_selector(
                     'text="Log in", button:has-text("Log in")',

jleechanorg_pr_automation-0.2.48/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

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/jleechanorg_pr_automation/orchestrated_pr_runner.py

@@ -35,6 +35,26 @@ def log(msg: str) -> None:
     print(f"{LOG_PREFIX} {msg}")
 
 
+def display_log_viewing_command(session_name: str) -> None:
+    """Display formatted log viewing commands for the given session."""
+    # Use same path resolution as task_dispatcher (relative to orchestration module)
+    try:
+        import orchestration.task_dispatcher
+        script_path = Path(orchestration.task_dispatcher.__file__).resolve().parent / "stream_logs.sh"
+    except (ImportError, AttributeError):
+        # Fallback to relative path if orchestration module not available
+        script_path = Path(__file__).resolve().parent.parent.parent / "orchestration" / "stream_logs.sh"
+
+    if script_path.exists():
+        log("")
+        log("📺 View formatted logs:")
+        log(f"   {script_path} {session_name}")
+        log("")
+        log("   Or use the shorter command:")
+        log(f"   ./orchestration/stream_logs.sh {session_name}")
+        log("")
+
+
 def run_cmd(
     cmd: List[str],
     cwd: Optional[Path] = None,
@@ -342,18 +362,16 @@ def dispatch_agent_for_pr_with_task(
                 "workspace_name": workspace_name,
             },
         )
-        # Inject model parameter only when Claude is in the CLI chain.
+        # Inject model parameter for all CLIs in the chain (Gemini, Claude, Cursor, etc.)
         if model:
-            cli_chain = [part.strip().lower() for part in str(agent_cli).split(",") if part.strip()]
-            if "claude" in cli_chain:
-                raw_model = str(model).strip()
-                if not re.fullmatch(r"[A-Za-z0-9_.-]+", raw_model):
-                    log(f"❌ Invalid model name requested: {raw_model!r}")
-                    return False
-                agent_spec["model"] = raw_model
+            raw_model = str(model).strip()
+            if not re.fullmatch(r"[A-Za-z0-9_.-]+", raw_model):
+                log(f"❌ Invalid model name requested: {raw_model!r}")
+                return False
         ok = dispatcher.create_dynamic_agent(agent_spec)
         if ok:
             log(f"Spawned agent for {repo_full}#{pr_number} at /tmp/{repo}/{workspace_name}")
+            display_log_viewing_command(session_name)
             success = True
         else:
             log(f"Failed to spawn agent for {repo_full}#{pr_number}")
@@ -394,6 +412,16 @@ def dispatch_agent_for_pr(
         f"FIXPR TASK (SELF-CONTAINED): Update PR #{pr_number} in {repo_full} (branch {branch}). "
         "Goal: resolve merge conflicts and failing checks. Also review and address any reviewer feedback that is blocking CI or mergeability. "
         f"CLI chain: {agent_cli}. DO NOT wait for additional input—start immediately.\n\n"
+        "⚠️ CRITICAL - REVIEW COMMENT REPLY API (MUST READ):\n"
+        "   To reply to inline review comments WITHOUT starting a pending review, use ONLY:\n"
+        f"   `gh api /repos/{repo_full}/pulls/{pr_number}/comments -f body='...' -F in_reply_to={{comment_id}}`\n"
+        "   This `/comments` endpoint with `in_reply_to` parameter creates a threaded reply WITHOUT starting a review.\n"
+        "   ⚠️ IMPORTANT: Use `-f` for body (string) and `-F` for in_reply_to (numeric comment ID).\n\n"
+        "   ❌ NEVER USE these (they create pending reviews that clutter the PR):\n"
+        "   - `create_pending_pull_request_review` MCP tool\n"
+        "   - `add_comment_to_pending_review` MCP tool\n"
+        "   - `POST /repos/.../pulls/.../reviews` endpoint\n"
+        "   - Any GitHub review workflow that requires 'submit'\n\n"
         "If /fixpr is unavailable, follow these steps explicitly (fallback for all CLIs including Claude):\n"
         f"1) gh pr checkout {pr_number}\n"
         "2) git status && git branch --show-current\n"
@@ -433,6 +461,7 @@ def dispatch_agent_for_pr(
         ok = dispatcher.create_dynamic_agent(agent_spec)
         if ok:
             log(f"Spawned agent for {repo_full}#{pr_number} at /tmp/{repo}/{workspace_name}")
+            display_log_viewing_command(session_name)
             success = True
         else:
             log(f"Failed to spawn agent for {repo_full}#{pr_number}")

jleechanorg_pr_automation-0.2.48/jleechanorg_pr_automation/tests/test_cleanup_pending_reviews.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+"""
+Tests for _cleanup_pending_reviews method and prompt API endpoint verification.
+
+Tests ensure:
+1. _cleanup_pending_reviews correctly identifies and deletes pending reviews
+2. Prompts contain the correct API endpoint for threaded replies
+"""
+
+import json
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock, patch
+
+from automation.jleechanorg_pr_automation import orchestrated_pr_runner as runner
+from jleechanorg_pr_automation.jleechanorg_pr_monitor import JleechanorgPRMonitor
+
+
+class TestCleanupPendingReviews(unittest.TestCase):
+    """Test _cleanup_pending_reviews method"""
+
+    def setUp(self):
+        """Set up test environment"""
+        with patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationSafetyManager'):
+            self.monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+            self.monitor.logger = Mock()
+
+    def test_cleanup_pending_reviews_deletes_pending_reviews(self):
+        """Test that pending reviews from automation user are deleted"""
+        repo_full = "owner/repo"
+        pr_number = 123
+
+        # Mock reviews API response with pending review from automation user
+        reviews_response = [
+            {
+                "id": 1001,
+                "state": "PENDING",
+                "user": {"login": "test-automation-user"},
+            },
+            {
+                "id": 1002,
+                "state": "APPROVED",
+                "user": {"login": "test-automation-user"},
+            },
+            {
+                "id": 1003,
+                "state": "PENDING",
+                "user": {"login": "other-user"},
+            },
+        ]
+
+        delete_calls = []
+
+        def mock_execute_subprocess(cmd, timeout=None, check=False):
+            if "reviews" in " ".join(cmd) and "DELETE" not in cmd:
+                # Fetch reviews command
+                return SimpleNamespace(
+                    returncode=0,
+                    stdout="\n".join(json.dumps(r) for r in reviews_response),
+                    stderr="",
+                )
+            elif "DELETE" in cmd:
+                # Delete review command
+                delete_calls.append(cmd)
+                return SimpleNamespace(returncode=0, stdout="", stderr="")
+            return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+        with patch(
+            "jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils.execute_subprocess_with_timeout",
+            side_effect=mock_execute_subprocess,
+        ):
+            self.monitor._cleanup_pending_reviews(repo_full, pr_number)
+
+        # Should only delete pending review from automation user (id 1001)
+        assert len(delete_calls) == 1, f"Expected 1 delete call, got {len(delete_calls)}"
+        assert "1001" in " ".join(delete_calls[0]), "Should delete review #1001"
+        self.monitor.logger.info.assert_any_call(
+            "🧹 Deleted pending review #1001 from test-automation-user on PR #123"
+        )
+        self.monitor.logger.info.assert_any_call("✅ Cleaned up 1 pending review(s) on PR #123")
+
+    def test_cleanup_pending_reviews_handles_no_pending_reviews(self):
+        """Test that method handles case with no pending reviews gracefully"""
+        repo_full = "owner/repo"
+        pr_number = 123
+
+        # Mock reviews API response with no pending reviews
+        reviews_response = [
+            {"id": 1001, "state": "APPROVED", "user": {"login": "test-automation-user"}},
+            {"id": 1002, "state": "COMMENTED", "user": {"login": "other-user"}},
+        ]
+
+        delete_calls = []
+
+        def mock_execute_subprocess(cmd, timeout=None, check=False):
+            if "reviews" in " ".join(cmd) and "DELETE" not in cmd:
+                return SimpleNamespace(
+                    returncode=0,
+                    stdout="\n".join(json.dumps(r) for r in reviews_response),
+                    stderr="",
+                )
+            elif "DELETE" in cmd:
+                delete_calls.append(cmd)
+            return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+        with patch(
+            "jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils.execute_subprocess_with_timeout",
+            side_effect=mock_execute_subprocess,
+        ):
+            self.monitor._cleanup_pending_reviews(repo_full, pr_number)
+
+        # Should not delete anything
+        assert len(delete_calls) == 0, "Should not delete any reviews when none are pending"
+        # Should not log cleanup success message
+        cleanup_logs = [
+            call.args[0] for call in self.monitor.logger.info.call_args_list if "Cleaned up" in call.args[0]
+        ]
+        assert len(cleanup_logs) == 0, "Should not log cleanup when no reviews deleted"
+
+    def test_cleanup_pending_reviews_handles_api_failure(self):
+        """Test that method handles API failure gracefully"""
+        repo_full = "owner/repo"
+        pr_number = 123
+
+        def mock_execute_subprocess(cmd, timeout=None, check=False):
+            if "reviews" in " ".join(cmd) and "DELETE" not in cmd:
+                # Simulate API failure
+                return SimpleNamespace(returncode=1, stdout="", stderr="API error")
+            return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+        with patch(
+            "jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils.execute_subprocess_with_timeout",
+            side_effect=mock_execute_subprocess,
+        ):
+            # Should not raise exception
+            self.monitor._cleanup_pending_reviews(repo_full, pr_number)
+
+        self.monitor.logger.debug.assert_called()
+
+    def test_cleanup_pending_reviews_handles_invalid_repo_format(self):
+        """Test that method handles invalid repo_full format"""
+        repo_full = "invalid-format"
+        pr_number = 123
+
+        self.monitor._cleanup_pending_reviews(repo_full, pr_number)
+
+        self.monitor.logger.warning.assert_called_with(
+            "Cannot parse repo_full 'invalid-format' for pending review cleanup"
+        )
+
+    def test_cleanup_pending_reviews_handles_exception(self):
+        """Test that method handles exceptions gracefully"""
+        repo_full = "owner/repo"
+        pr_number = 123
+
+        def mock_execute_subprocess(cmd, timeout=None, check=False):
+            raise Exception("Unexpected error")
+
+        with patch(
+            "jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils.execute_subprocess_with_timeout",
+            side_effect=mock_execute_subprocess,
+        ):
+            # Should not raise exception
+            self.monitor._cleanup_pending_reviews(repo_full, pr_number)
+
+        self.monitor.logger.debug.assert_called()
+
+    def test_cleanup_pending_reviews_deletes_multiple_pending_reviews(self):
+        """Test that multiple pending reviews from automation user are all deleted"""
+        repo_full = "owner/repo"
+        pr_number = 123
+
+        # Mock reviews API response with multiple pending reviews from automation user
+        reviews_response = [
+            {"id": 1001, "state": "PENDING", "user": {"login": "test-automation-user"}},
+            {"id": 1002, "state": "PENDING", "user": {"login": "test-automation-user"}},
+            {"id": 1003, "state": "PENDING", "user": {"login": "other-user"}},
+        ]
+
+        delete_calls = []
+
+        def mock_execute_subprocess(cmd, timeout=None, check=False):
+            if "reviews" in " ".join(cmd) and "DELETE" not in cmd:
+                return SimpleNamespace(
+                    returncode=0,
+                    stdout="\n".join(json.dumps(r) for r in reviews_response),
+                    stderr="",
+                )
+            elif "DELETE" in cmd:
+                delete_calls.append(cmd)
+                return SimpleNamespace(returncode=0, stdout="", stderr="")
+            return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+        with patch(
+            "jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils.execute_subprocess_with_timeout",
+            side_effect=mock_execute_subprocess,
+        ):
+            self.monitor._cleanup_pending_reviews(repo_full, pr_number)
+
+        # Should delete both pending reviews from automation user
+        assert len(delete_calls) == 2, f"Expected 2 delete calls, got {len(delete_calls)}"
+        self.monitor.logger.info.assert_any_call("✅ Cleaned up 2 pending review(s) on PR #123")
+
+    def test_cleanup_pending_reviews_handles_null_user(self):
+        """Test that method handles null user gracefully (prevents AttributeError)"""
+        repo_full = "owner/repo"
+        pr_number = 123
+
+        # Mock reviews API response with pending review with null user
+        reviews_response = [
+            {
+                "id": 1001,
+                "state": "PENDING",
+                "user": None,  # API can return null user
+            },
+            {
+                "id": 1002,
+                "state": "PENDING",
+                "user": {"login": "test-automation-user"},
+            },
+        ]
+
+        delete_calls = []
+
+        def mock_execute_subprocess(cmd, timeout=None, check=False):
+            if "reviews" in " ".join(cmd) and "DELETE" not in cmd:
+                return SimpleNamespace(
+                    returncode=0,
+                    stdout="\n".join(json.dumps(r) for r in reviews_response),
+                    stderr="",
+                )
+            elif "DELETE" in cmd:
+                delete_calls.append(cmd)
+                return SimpleNamespace(returncode=0, stdout="", stderr="")
+            return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+        with patch(
+            "jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationUtils.execute_subprocess_with_timeout",
+            side_effect=mock_execute_subprocess,
+        ):
+            # Should not raise AttributeError
+            self.monitor._cleanup_pending_reviews(repo_full, pr_number)
+
+        # Should only delete pending review from automation user (id 1002), not null user (id 1001)
+        assert len(delete_calls) == 1, f"Expected 1 delete call, got {len(delete_calls)}"
+        assert "1002" in " ".join(delete_calls[0]), "Should delete review #1002 (with valid user)"
+        assert "1001" not in " ".join(delete_calls[0]), "Should NOT delete review #1001 (null user)"
+
+
+class TestPromptAPIEndpoint(unittest.TestCase):
+    """Test that prompts contain correct API endpoint"""
+
+    def setUp(self):
+        """Set up test environment"""
+        with patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationSafetyManager'):
+            self.monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+
+    def test_fix_comment_prompt_contains_correct_endpoint(self):
+        """Test that fix-comment prompt contains correct API endpoint"""
+        repository = "owner/repo"
+        pr_number = 123
+        pr_data = {"headRefName": "feature/branch"}
+        head_sha = "abc123def456"
+
+        prompt = self.monitor._build_fix_comment_prompt_body(
+            repository, pr_number, pr_data, head_sha, agent_cli="claude"
+        )
+
+        # Should contain correct endpoint: /comments with in_reply_to parameter
+        assert "/pulls/123/comments" in prompt, "Prompt should contain /comments endpoint"
+        assert "in_reply_to" in prompt, "Prompt should contain in_reply_to parameter"
+        assert "-F in_reply_to" in prompt, "Prompt should use -F flag for numeric parameter"
+        assert "-f body" in prompt, "Prompt should use -f flag for string parameter"
+
+        # Should NOT contain incorrect endpoint
+        assert "/comments/{comment_id}/replies" not in prompt, "Prompt should NOT contain incorrect /replies endpoint"
+
+    def test_orchestrated_pr_runner_prompt_contains_correct_endpoint(self):
+        """Test that orchestrated_pr_runner prompt contains correct API endpoint"""
+        repo_full = "owner/repo"
+        pr_number = 123
+        branch = "feature/branch"
+        agent_cli = "claude"
+
+        # Get the task description from dispatch_agent_for_pr
+        class FakeDispatcher:
+            def __init__(self):
+                self.task_description = None
+
+            def analyze_task_and_create_agents(self, task_description, forced_cli=None):
+                self.task_description = task_description
+                return [{"id": "agent"}]
+
+            def create_dynamic_agent(self, spec):
+                return True
+
+        dispatcher = FakeDispatcher()
+        pr = {"repo_full": repo_full, "repo": "repo", "number": pr_number, "branch": branch}
+
+        with patch.object(runner, "WORKSPACE_ROOT_BASE", Path("/tmp")):
+            with patch.object(runner, "kill_tmux_session_if_exists", lambda _: None):
+                with patch.object(runner, "prepare_workspace_dir", lambda repo, name: None):
+                    runner.dispatch_agent_for_pr(dispatcher, pr, agent_cli=agent_cli)
+
+        assert dispatcher.task_description is not None, "Task description should be set"
+        prompt = dispatcher.task_description
+
+        # Should contain correct endpoint: /comments with in_reply_to parameter
+        assert "/pulls/123/comments" in prompt, "Prompt should contain /comments endpoint"
+        assert "in_reply_to" in prompt, "Prompt should contain in_reply_to parameter"
+        assert "-F in_reply_to" in prompt, "Prompt should use -F flag for numeric parameter"
+        assert "-f body" in prompt, "Prompt should use -f flag for string parameter"
+
+        # Should NOT contain incorrect endpoint
+        assert "/comments/{comment_id}/replies" not in prompt, "Prompt should NOT contain incorrect /replies endpoint"
+
+
+if __name__ == "__main__":
+    unittest.main()

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/jleechanorg_pr_automation/tests/test_model_parameter.py

@@ -10,7 +10,10 @@ import unittest
 from types import SimpleNamespace
 from unittest.mock import MagicMock, patch
 
-from jleechanorg_pr_automation.jleechanorg_pr_monitor import JleechanorgPRMonitor
+from jleechanorg_pr_automation.jleechanorg_pr_monitor import (
+    JleechanorgPRMonitor,
+    _normalize_model,
+)
 
 
 class TestModelParameter(unittest.TestCase):
@@ -228,15 +231,11 @@ class TestModelParameter(unittest.TestCase):
 
     def test_normalize_model_none_returns_none(self):
         """Test that _normalize_model returns None for None input."""
-        from jleechanorg_pr_automation.jleechanorg_pr_monitor import _normalize_model
-        
         result = _normalize_model(None)
         self.assertIsNone(result)
 
     def test_normalize_model_empty_string_returns_none(self):
         """Test that _normalize_model returns None for empty string."""
-        from jleechanorg_pr_automation.jleechanorg_pr_monitor import _normalize_model
-        
         result = _normalize_model("")
         self.assertIsNone(result)
         
@@ -245,8 +244,6 @@ class TestModelParameter(unittest.TestCase):
 
     def test_normalize_model_valid_names(self):
         """Test that _normalize_model accepts valid model names."""
-        from jleechanorg_pr_automation.jleechanorg_pr_monitor import _normalize_model
-        
         valid_models = [
             "sonnet",
             "opus",
@@ -272,8 +269,6 @@ class TestModelParameter(unittest.TestCase):
 
     def test_normalize_model_invalid_names_raises_error(self):
         """Test that _normalize_model rejects invalid model names."""
-        from jleechanorg_pr_automation.jleechanorg_pr_monitor import _normalize_model
-        
         invalid_models = [
             "model with spaces",
             "model@invalid",
@@ -311,8 +306,6 @@ class TestModelParameter(unittest.TestCase):
 
     def test_normalize_model_strips_whitespace(self):
         """Test that _normalize_model strips whitespace from valid names."""
-        from jleechanorg_pr_automation.jleechanorg_pr_monitor import _normalize_model
-        
         result = _normalize_model("  sonnet  ")
         self.assertEqual(result, "sonnet")
         

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/jleechanorg_pr_automation/tests/test_pr_targeting.py

@@ -190,7 +190,7 @@ class TestPRTargeting(unittest.TestCase):
         self.assertIn("review comments", prompt)
         self.assertIn("issue comments", prompt)
         # After fix for comment #2669657213, prompt clarifies:
-        # - Inline review comments use: /pulls/{pr_number}/comments/{comment_id}/replies
+        # - Inline review comments use: /pulls/{pr_number}/comments with -F in_reply_to={comment_id}
         # - Issue comments don't support threading (top-level comments only)
         self.assertIn("pulls/42/comments", prompt)  # Updated to match actual PR number in prompt
         self.assertIn("reply individually to each comment", prompt)  # Issue comments clarification

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/jleechanorg_pr_automation/utils.py

@@ -189,7 +189,7 @@ def get_automation_limits_with_overrides(overrides: Optional[Mapping[str, Any]]
     defaults: Dict[str, int] = {
         # Global PR limit: counts ALL attempts across ALL workflows
         "pr_limit": pr_limit,
-        "global_limit": coerce_positive_int(os.getenv("AUTOMATION_GLOBAL_LIMIT"), default=50),
+        "global_limit": coerce_positive_int(os.getenv("AUTOMATION_GLOBAL_LIMIT"), default=100),
         "approval_hours": 24,
         "subprocess_timeout": 300,
         # Workflow-specific limits: 10 attempts per workflow (counts ALL attempts)

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/jleechanorg_pr_automation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jleechanorg-pr-automation
-Version: 0.2.41
+Version: 0.2.48
 Summary: GitHub PR automation system with safety limits and actionable counting
 Author-email: jleechan <jlee@jleechan.org>
 License-Expression: MIT

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/jleechanorg_pr_automation.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ jleechanorg_pr_automation/openai_automation/__init__.py
 jleechanorg_pr_automation/openai_automation/codex_github_mentions.py
 jleechanorg_pr_automation/openai_automation/debug_page_content.py
 jleechanorg_pr_automation/openai_automation/oracle_cli.py
+jleechanorg_pr_automation/openai_automation/test_auth_restoration.py
 jleechanorg_pr_automation/openai_automation/test_codex_comprehensive.py
 jleechanorg_pr_automation/openai_automation/test_codex_integration.py
 jleechanorg_pr_automation/tests/__init__.py
@@ -32,6 +33,7 @@ jleechanorg_pr_automation/tests/test_automation_marker_functions.py
 jleechanorg_pr_automation/tests/test_automation_over_running_reproduction.py
 jleechanorg_pr_automation/tests/test_automation_safety_limits.py
 jleechanorg_pr_automation/tests/test_automation_safety_manager_comprehensive.py
+jleechanorg_pr_automation/tests/test_cleanup_pending_reviews.py
 jleechanorg_pr_automation/tests/test_codex_actor_matching.py
 jleechanorg_pr_automation/tests/test_fixpr_prompt.py
 jleechanorg_pr_automation/tests/test_fixpr_return_value.py

{jleechanorg_pr_automation-0.2.41 → jleechanorg_pr_automation-0.2.48}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jleechanorg-pr-automation"
-version = "0.2.41"
+version = "0.2.48"
 description = "GitHub PR automation system with safety limits and actionable counting"
 authors = [
     { name = "jleechan", email = "jlee@jleechan.org" },