How to Receive GitHub Webhooks on Localhost without a Proxy

import requests

def listen_to_github():
    # Pull latest GitHub events
    res = requests.get("https://api.fetchhook.app/api/v1/stash_github_dev",
                       headers={"Authorization": "Bearer fh_live_xxx"})

    for event in res.json().get('events', []):
        payload = event['payload']
        repo = payload.get('repository', {}).get('name')
        action = payload.get('action')
        print(f"GitHub Event: {action} on {repo}")

GitHub Repo → Settings → Webhooks → Add webhook

Payload URL:
https://api.fetchhook.app/in/stash_github_dev

Content type:
application/json

Secret: (optional, for signature verification)
your_webhook_secret_here

Which events would you like to trigger this webhook?
○ Just the push event
○ Send me everything
● Let me select individual events:
  ✓ Pull requests
  ✓ Issues
  ✓ Issue comments
  ✓ Pull request reviews
  ✓ Workflow runs

Active: ✓

After adding, GitHub sends a "ping" event to test.
FetchHook responds instantly → Webhook is active!

Traditional (ngrok to localhost):
GitHub sends PR webhook → ngrok (200ms) → localhost (processing 15s)
→ GitHub timeout @ 10s → Marks as failed → Retry
→ Retry times out again → GitHub disables webhook

FetchHook:
GitHub sends PR webhook → FetchHook (50ms) → HTTP 202 success
→ GitHub happy, marks as delivered
→ Your script pulls when ready
→ Process PR (15s) → No timeout pressure

import requests
import os

FETCHHOOK_API_KEY = os.getenv("FETCHHOOK_API_KEY")

# Event handlers
def handle_pull_request(payload):
    action = payload['action']
    pr = payload['pull_request']

    if action == 'opened':
        print(f"New PR opened: {pr['title']}")
        # Run automated code review
        review_pr_with_llm(pr)
    elif action == 'closed' and pr.get('merged'):
        print(f"PR merged: {pr['title']}")
        # Trigger deployment
        deploy_to_staging()

def handle_issues(payload):
    action = payload['action']
    issue = payload['issue']

    if action == 'opened':
        print(f"New issue: {issue['title']}")
        # Auto-triage with labels
        auto_label_issue(issue)

def handle_issue_comment(payload):
    comment = payload['comment']
    issue = payload['issue']
    print(f"Comment on issue #{issue['number']}: {comment['body'][:50]}")

    # Check for bot commands
    if '@bot' in comment['body']:
        process_bot_command(comment, issue)

# Router
def process_github_event(event):
    event_type = event.get('metadata', {}).get('github_event')
    payload = event['payload']

    handlers = {
        'pull_request': handle_pull_request,
        'issues': handle_issues,
        'issue_comment': handle_issue_comment,
        'push': handle_push,
    }

    handler = handlers.get(event_type)
    if handler:
        handler(payload)
    else:
        print(f"Unhandled event: {event_type}")

# Main loop
def listen_to_github():
    response = requests.get(
        "https://api.fetchhook.app/api/v1/stash_github_dev",
        headers={"Authorization": f"Bearer {FETCHHOOK_API_KEY}"}
    )

    events = response.json().get('events', [])
    for event in events:
        if event.get('signature_verified'):
            process_github_event(event)

listen_to_github()

import openai
import requests

def review_pr_with_llm(pr):
    """
    Automated code review bot triggered by PR webhook.
    Uses LLM to analyze code changes.
    """
    # Fetch PR diff
    diff_url = pr['diff_url']
    diff = requests.get(diff_url).text

    # Analyze with LLM (takes 10-30 seconds - no timeout with FetchHook)
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{
            "role": "user",
            "content": f"Review this code change and suggest improvements:\n\n{diff}"
        }]
    )

    review_comment = response.choices[0].message.content

    # Post review comment on PR via GitHub API
    comments_url = pr['comments_url']
    requests.post(comments_url, json={
        "body": f"🤖 Automated Code Review:\n\n{review_comment}"
    }, headers={
        "Authorization": f"Bearer {os.getenv('GITHUB_TOKEN')}"
    })

    print(f"Posted review on PR #{pr['number']}")

# Webhook trigger
def handle_pull_request(payload):
    if payload['action'] == 'opened':
        review_pr_with_llm(payload['pull_request'])

# Terminal 1: Run your GitHub automation script
python github_bot.py

# Terminal 2: Trigger test events
# Option 1: Manual actions in GitHub UI
# - Open a test issue
# - Create a test PR
# - Add a comment

# Option 2: Use GitHub API to create events
curl -X POST https://api.github.com/repos/user/repo/issues \
  -H "Authorization: Bearer YOUR_GITHUB_TOKEN" \
  -d '{"title":"Test issue for webhook testing"}'

# Option 3: Redeliver previous webhook
# GitHub Settings → Webhooks → Recent Deliveries → Redeliver

# Your script pulls and processes automatically

# AWS Lambda handler (triggered by EventBridge every 2 minutes)
import boto3
import requests
import os

def lambda_handler(event, context):
    # Pull GitHub events from FetchHook
    response = requests.get(
        f"https://api.fetchhook.app/api/v1/{os.getenv('SOURCE_ID')}",
        headers={"Authorization": f"Bearer {os.getenv('FETCHHOOK_API_KEY')}"}
    )

    events = response.json().get('events', [])
    print(f"Processing {len(events)} GitHub events")

    for event in events:
        if event.get('signature_verified'):
            process_github_event(event)

    return {
        'statusCode': 200,
        'body': f'Processed {len(events)} events'
    }

# Environment variables:
# SOURCE_ID=stash_github_prod
# FETCHHOOK_API_KEY=fh_prod_xxx
# GITHUB_TOKEN=ghp_xxx (for GitHub API calls)