/**
 * Minimal Worker pass-through proxy
 * - Target URL from ?url=, X-Target-URL, or /https://...
 * - Proxies method/headers/body to upstream; relays response
 */
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  try {
    const url = new URL(request.url)
    const targetUrl = getTargetUrl(url, request.headers)

    if (!targetUrl) {
      return errorJSON('No target URL specified', 400, {
        usage: {
          query_param: '?url=https://example.com',
          header: 'X-Target-URL: https://example.com',
          path: '/https://example.com'
        }
      })
    }

    let target
    try { target = new URL(targetUrl) } catch (e) {
      return errorJSON('Invalid target URL', 400, { provided: targetUrl })
    }

    // Forward original query params except control ones
    const passthru = new URLSearchParams()
    for (const [k, v] of url.searchParams) {
      if (!['url', '_cb', '_t'].includes(k)) passthru.append(k, v)
    }
    if (passthru.toString()) target.search = passthru.toString()

    // Build proxied request
    const proxyReq = buildProxyRequest(request, target)
    const upstream = await fetch(proxyReq)

    return buildProxyResponse(upstream, request.method)
  } catch (error) {
    return errorJSON('Proxy request failed', 500, {
      message: error.message,
      timestamp: new Date().toISOString()
    })
  }
}

function getTargetUrl(url, headers) {
  let t = url.searchParams.get('url') || headers.get('X-Target-URL')
  if (!t && url.pathname !== '/') {
    const p = url.pathname.slice(1)
    if (p.startsWith('http')) t = p
  }
  return t
}

function buildProxyRequest(request, target) {
  const h = new Headers()
  const allow = [
    'accept','accept-language','accept-encoding','authorization',
    'cache-control','content-type','origin','referer','user-agent'
  ]
  for (const [k, v] of request.headers) {
    if (allow.includes(k.toLowerCase())) h.set(k, v)
  }
  h.set('Host', target.hostname)

  // Optional: spoof X-Forwarded-For if provided
  const spoof = request.headers.get('X-My-X-Forwarded-For')
  h.set('X-Forwarded-For', spoof || randomIP())

  return new Request(target.toString(), {
    method: request.method,
    headers: h,
    body: ['GET','HEAD'].includes(request.method) ? null : request.body
  })
}

function buildProxyResponse(resp, method) {
  const h = new Headers()
  for (const [k, v] of resp.headers) {
    if (!['content-encoding','content-length','transfer-encoding'].includes(k.toLowerCase())) {
      h.set(k, v)
    }
  }
  // Permissive CORS for tooling convenience
  h.set('Access-Control-Allow-Origin', '*')
  h.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, PATCH, HEAD')
  h.set('Access-Control-Allow-Headers', '*')

  if (method === 'OPTIONS') return new Response(null, { status: 204, headers: h })
  return new Response(resp.body, { status: resp.status, statusText: resp.statusText, headers: h })
}

function errorJSON(msg, status=400, extra={}) {
  return new Response(JSON.stringify({ error: msg, ...extra }), {
    status, headers: { 'Content-Type': 'application/json' }
  })
}

function randomIP() { return [1,2,3,4].map(() => Math.floor(Math.random()*255)+1).join('.') }

#!/usr/bin/env python3
from flareprox import FlareProx, FlareProxError
import json

# Initialize
flareprox = FlareProx(config_file="flareprox.json")
if not flareprox.is_configured:
    print("FlareProx not configured. Run: python3 flareprox.py config")
    exit(1)

# Ensure endpoints exist
endpoints = flareprox.sync_endpoints()
if not endpoints:
    print("Creating proxy endpoints...")
    flareprox.create_proxies(count=2)

# Make a POST request through a random endpoint
try:
    post_data = json.dumps({
        "username": "testuser",
        "message": "Hello from FlareProx!",
        "timestamp": "2025-01-01T12:00:00Z"
    })

    headers = {
        "Content-Type": "application/json",
        "User-Agent": "FlareProx-Client/1.0"
    }

    response = flareprox.redirect_request(
        target_url="https://httpbin.org/post",
        method="POST",
        headers=headers,
        data=post_data
    )

    if response.status_code == 200:
        result = response.json()
        print("✓ POST successful via FlareProx")
        print(f"Origin IP: {result.get('origin', 'unknown')}")
        print(f"Posted data: {result.get('json', {})}")
    else:
        print(f"Request failed with status: {response.status_code}")

except FlareProxError as e:
    print(f"FlareProx error: {e}")
except Exception as e:
    print(f"Request error: {e}")