Initial commit - PR-Agent OSS release

pr_agent/servers/github_app_webhook.py

@@ -0,0 +1,78 @@
+import logging
+import sys
+
+import uvicorn
+from fastapi import APIRouter, FastAPI, HTTPException, Request, Response
+
+from pr_agent.agent.pr_agent import PRAgent
+from pr_agent.config_loader import settings
+from pr_agent.servers.utils import verify_signature
+
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
+router = APIRouter()
+
+
+@router.post("/api/v1/github_webhooks")
+async def handle_github_webhooks(request: Request, response: Response):
+    logging.debug("Received a github webhook")
+    try:
+        body = await request.json()
+    except Exception as e:
+        logging.error("Error parsing request body", e)
+        raise HTTPException(status_code=400, detail="Error parsing request body") from e
+    body_bytes = await request.body()
+    signature_header = request.headers.get('x-hub-signature-256', None)
+    try:
+        webhook_secret = settings.github.webhook_secret
+    except AttributeError:
+        webhook_secret = None
+    if webhook_secret:
+        verify_signature(body_bytes, webhook_secret, signature_header)
+    logging.debug(f'Request body:\n{body}')
+    return await handle_request(body)
+
+
+async def handle_request(body):
+    action = body.get("action", None)
+    installation_id = body.get("installation", {}).get("id", None)
+    agent = PRAgent(installation_id)
+    if action == 'created':
+        if "comment" not in body:
+            return {}
+        comment_body = body.get("comment", {}).get("body", None)
+        if "says 'Please" in comment_body:
+            return {}
+        if "issue" not in body and "pull_request" not in body["issue"]:
+            return {}
+        pull_request = body["issue"]["pull_request"]
+        api_url = pull_request.get("url", None)
+        await agent.handle_request(api_url, comment_body)
+
+    elif action in ["opened"] or 'reopened' in action:
+        pull_request = body.get("pull_request", None)
+        if not pull_request:
+            return {}
+        api_url = pull_request.get("url", None)
+        if api_url is None:
+            return {}
+        await agent.handle_request(api_url, "please review")
+    else:
+        return {}
+
+
+@router.get("/")
+async def root():
+    return {"status": "ok"}
+
+
+def start():
+    if settings.get("GITHUB.DEPLOYMENT_TYPE", "user") != "app":
+        raise Exception("Please set deployment type to app in .secrets.toml file")
+    app = FastAPI()
+    app.include_router(router)
+
+    uvicorn.run(app, host="0.0.0.0", port=3000)
+
+
+if __name__ == '__main__':
+    start()

pr_agent/servers/github_polling.py

@@ -0,0 +1,73 @@
+import asyncio
+import logging
+import sys
+from datetime import datetime, timezone
+
+import aiohttp
+
+from pr_agent.agent.pr_agent import PRAgent
+from pr_agent.config_loader import settings
+
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
+NOTIFICATION_URL = "https://api.github.com/notifications"
+
+
+def now() -> str:
+    now_utc = datetime.now(timezone.utc).isoformat()
+    now_utc = now_utc.replace("+00:00", "Z")
+    return now_utc
+
+
+async def polling_loop():
+    since = [now()]
+    last_modified = [None]
+    try:
+        deployment_type = settings.github.deployment_type
+        token = settings.github.user_token
+    except AttributeError:
+        deployment_type = 'none'
+        token = None
+    if deployment_type != 'user':
+        raise ValueError("Deployment mode must be set to 'user' to get notifications")
+    if not token:
+        raise ValueError("User token must be set to get notifications")
+    async with aiohttp.ClientSession() as session:
+        while True:
+            headers = {
+                "Accept": "application/vnd.github.v3+json",
+                "Authorization": f"Bearer {token}"
+            }
+            params = {
+                "participating": "true"
+            }
+            if since[0]:
+                params["since"] = since[0]
+            if last_modified[0]:
+                headers["If-Modified-Since"] = last_modified[0]
+            async with session.get(NOTIFICATION_URL, headers=headers, params=params) as response:
+                if response.status == 200:
+                    if 'Last-Modified' in response.headers:
+                        last_modified[0] = response.headers['Last-Modified']
+                        since[0] = None
+                    notifications = await response.json()
+                    for notification in notifications:
+                        if 'reason' in notification and notification['reason'] == 'mention':
+                            if 'subject' in notification and notification['subject']['type'] == 'PullRequest':
+                                pr_url = notification['subject']['url']
+                                latest_comment = notification['subject']['latest_comment_url']
+                                async with session.get(latest_comment, headers=headers) as comment_response:
+                                    if comment_response.status == 200:
+                                        comment = await comment_response.json()
+                                        comment_body = comment['body'] if 'body' in comment else ''
+                                        commenter_github_user = comment['user']['login'] if 'user' in comment else ''
+                                        logging.info(f"Commenter: {commenter_github_user}\nComment: {comment_body}")
+                                        if comment_body.strip().startswith("@"):
+                                            agent = PRAgent()
+                                            await agent.handle_request(pr_url, comment_body)
+                elif response.status != 304:
+                    print(f"Failed to fetch notifications. Status code: {response.status}")
+
+            await asyncio.sleep(5)
+
+if __name__ == '__main__':
+    asyncio.run(polling_loop())

pr_agent/servers/utils.py

@@ -0,0 +1,23 @@
+import hashlib
+import hmac
+
+from fastapi import HTTPException
+
+
+def verify_signature(payload_body, secret_token, signature_header):
+    """Verify that the payload was sent from GitHub by validating SHA256.
+
+    Raise and return 403 if not authorized.
+
+    Args:
+        payload_body: original request body to verify (request.body())
+        secret_token: GitHub app webhook token (WEBHOOK_SECRET)
+        signature_header: header received from GitHub (x-hub-signature-256)
+    """
+    if not signature_header:
+        raise HTTPException(status_code=403, detail="x-hub-signature-256 header is missing!")
+    hash_object = hmac.new(secret_token.encode('utf-8'), msg=payload_body, digestmod=hashlib.sha256)
+    expected_signature = "sha256=" + hash_object.hexdigest()
+    if not hmac.compare_digest(expected_signature, signature_header):
+        raise HTTPException(status_code=403, detail="Request signatures didn't match!")
+