openhop

srcCódigo fuente

Código fuente

Todos los archivos de la última versión de openhop, tal cual están publicados. Lee lo que quieras o descárgalo todo en un zip.

Commit
c8cfb4c
Fecha
16 nov 2026
Archivos
62 archivos
Descargar el código (zip)

zip · 758 KB · SHA-256 6ce65b028777bf92…

zen_proxy.py

557 líneas · 21 KB · Python

"""Local IPv6-pinning HTTP/CONNECT proxy bound to Cloudflare WARP on Windows."""
from __future__ import annotations
import os
import random
import select
import socket
import socketserver
import sys
import threading
import time
import urllib.parse
from ouc_common import (
EGRESS_EPOCH_FILE,
KEEPER_LOG_FILE,
LANE_DIR,
append_log,
ensure_dirs,
fetch_opencode_aaaa_pool,
get_warp_local_v6,
is_keeper_paused,
normalize_v6_64,
)
PINNED_HOSTS = {
"opencode.ai",
"www.opencode.ai",
"api.opencode.ai",
"opencode.com",
"www.opencode.com",
"api.opencode.com",
"inference.opencode.ai",
}
# Bumped (via EGRESS_EPOCH_FILE) whenever the exit IP changes. OpenCode tunnels opened before that are
# closed, so the next request goes out on the new IP instead of reusing a connection on the old one.
_EPOCH = {"v": 0.0}
def _file_epoch() -> float:
try:
return EGRESS_EPOCH_FILE.stat().st_mtime
except OSError:
return 0.0
def _is_opencode(host: str) -> bool:
host = (host or "").strip("[]").lower()
return host in PINNED_HOSTS or host.endswith(".opencode.ai") or host.endswith(".opencode.com")
class _WarpState:
"""Thread-safe cache for active WARP IPv6 and auto-rotated pinned edge."""
def __init__(self, pool: list[str], initial_edge: str, ttl: float = 1.5) -> None:
self._ttl = ttl
self._lock = threading.Lock()
self._ts = 0.0
self._v6: str | None = None
self._last_prefix: str = ""
self._pool = pool
self._edge = initial_edge
self._reroll_mtime = 0.0
def _apply_edge_controls(self) -> None:
override_file = LANE_DIR / "edge_override.txt"
reroll_file = LANE_DIR / "edge_reroll"
if not os.environ.get("OUC_PIN_EDGE") and override_file.is_file():
try:
val = override_file.read_text(encoding="utf-8").strip()
if val and val.lower() != "auto" and ":" in val:
self._edge = val
(LANE_DIR / "last_edge.txt").write_text(val + "\n", encoding="utf-8")
return
except Exception:
pass
if reroll_file.is_file():
try:
mtime = reroll_file.stat().st_mtime
if mtime > self._reroll_mtime:
self._reroll_mtime = mtime
fresh_pool = fetch_opencode_aaaa_pool() or self._pool
self._pool = fresh_pool
choices = [c for c in fresh_pool if c != self._edge] or fresh_pool
self._edge = random.choice(choices)
(LANE_DIR / "last_edge.txt").write_text(self._edge + "\n", encoding="utf-8")
except Exception:
pass
def poll_controls(self) -> None:
"""Refresh edge override / reroll state immediately without waiting for traffic."""
with self._lock:
self._apply_edge_controls()
def get(self, wait_if_rotating: bool = True) -> tuple[str | None, str]:
deadline = time.monotonic() + (18.0 if wait_if_rotating else 0.0)
while True:
now = time.monotonic()
with self._lock:
if now - self._ts < self._ttl and self._v6:
return self._v6, self._edge
v6 = get_warp_local_v6()
with self._lock:
self._ts = time.monotonic()
self._v6 = v6
if v6:
prefix = normalize_v6_64(v6)
if prefix and self._last_prefix and prefix != self._last_prefix:
if not os.environ.get("OUC_PIN_EDGE"):
fresh_pool = fetch_opencode_aaaa_pool() or self._pool
self._pool = fresh_pool
self._edge = random.choice(fresh_pool)
try:
(LANE_DIR / "last_edge.txt").write_text(
self._edge + "\n", encoding="utf-8"
)
except Exception:
pass
if prefix:
self._last_prefix = prefix
self._apply_edge_controls()
edge = self._edge
if v6:
return v6, edge
if not wait_if_rotating or not is_keeper_paused() or time.monotonic() >= deadline:
return None, edge
time.sleep(0.75)
class _ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
# On Windows SO_REUSEADDR lets a second process bind the same port and silently
# steal connections, so use an exclusive bind there instead.
allow_reuse_address = sys.platform != "win32"
daemon_threads = True
def server_bind(self) -> None:
if sys.platform == "win32" and hasattr(socket, "SO_EXCLUSIVEADDRUSE"):
try:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
except OSError:
pass
super().server_bind()
_last_err_log: dict[str, float] = {}
class NoRealIpError(ConnectionRefusedError):
"""The only way out for OpenCode would be the user's own IP. Never fall back to a direct connection."""
NO_REAL_IP_REASON = (
"openhop: WARP isn't protecting the connection right now, so OpenCode was not sent out with your "
"own IP. openhop is reconnecting WARP - try again in a minute"
)
def _is_strict() -> bool:
return os.environ.get("OUC_STRICT_PROXY") == "1" or (LANE_DIR / "strict_proxy.flag").is_file()
def _friendly_reason(host: str, exc: BaseException, strict: bool) -> str:
"""Short, human-readable 503 reason shown by OpenCode (raw details go to the keeper log)."""
now = time.monotonic()
if now - _last_err_log.get(host, 0.0) > 30.0:
_last_err_log[host] = now
try:
append_log(KEEPER_LOG_FILE, f"proxy: could not reach {host}: {type(exc).__name__}: {exc}")
except Exception:
pass
if strict:
return "openhop: WARP is down and Strict Fail-Closed mode is ON - reconnect WARP or turn Strict mode off"
return f"openhop: cannot reach {host} - check your internet / WARP connection"
def _relay(a: socket.socket, b: socket.socket, watch_epoch: bool = False) -> None:
"""Bidirectionally forward bytes between two sockets with TCP keepalive and resilient streaming.
watch_epoch: close the tunnel as soon as the exit IP changes (OpenCode tunnels only).
"""
sockets = [a, b]
start_epoch = _EPOCH["v"]
closed = set()
for s in (a, b):
try:
s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
# Windows TCP keepalive parameters: idle 15s, interval 5s
if hasattr(socket, "SIO_KEEPALIVE_VALS"):
s.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 15000, 5000))
# Linux TCP keepalive parameters: idle 15s, interval 5s, 5 probes
if hasattr(socket, "TCP_KEEPIDLE"):
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 15)
if hasattr(socket, "TCP_KEEPINTVL"):
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 5)
if hasattr(socket, "TCP_KEEPCNT"):
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 5)
except Exception:
pass
last_active = time.monotonic()
try:
while sockets:
if watch_epoch and _EPOCH["v"] != start_epoch:
break # new exit IP: drop this tunnel so OpenCode reconnects through the new one
readable, _, exceptional = select.select(sockets, [], sockets, 1.0 if watch_epoch else 5.0)
if exceptional:
break
if not readable:
# Generous 15-minute idle ceiling for long-thinking models (DeepSeek V4.1 reasoning)
if time.monotonic() - last_active > 900.0:
break
continue
last_active = time.monotonic()
for src in readable:
dst = b if src is a else a
try:
data = src.recv(65536)
except (OSError, ConnectionResetError):
data = b""
if data:
try:
dst.sendall(data)
except (OSError, ConnectionResetError):
return
else:
# EOF from src -> send TCP FIN to dst (half-close)
closed.add(src)
if src in sockets:
sockets.remove(src)
try:
dst.shutdown(socket.SHUT_WR)
except OSError:
pass
if len(closed) >= 2:
return
except Exception:
pass
def _open_pinned_v6(dest_ip: str, port: int, local_v6: str, timeout: float = 12.0) -> socket.socket:
"""Open an IPv6 TCP socket explicitly bound to the WARP tunnel IPv6 address."""
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
sock.settimeout(timeout)
try:
sock.bind((local_v6, 0))
sock.connect((dest_ip, port))
sock.settimeout(None)
return sock
except Exception:
sock.close()
raise
def _open_warp_direct(
clean_host: str,
port: int,
warp_state: _WarpState,
) -> socket.socket:
from ouc_common import current_warp_scope
scope = current_warp_scope()
is_strict = os.environ.get("OUC_STRICT_PROXY") == "1" or (LANE_DIR / "strict_proxy.flag").is_file()
is_opencode_host = (
clean_host in PINNED_HOSTS
or clean_host.endswith(".opencode.ai")
or clean_host.endswith(".opencode.com")
)
# 1. Isolated (App-Only) mode: tunnel via local WARP SOCKS5 proxy (port 40000).
# The timeout covers WARP's own connect to the server, which over MASQUE can take a few seconds,
# so 2 s used to fail on slow links and silently fall back to a direct connection below.
if scope == "isolated":
from tor_manager import open_socks5_tunnel
if is_opencode_host:
from ouc_common import warp_path_leaking
if warp_path_leaking():
# WARP says "Connected" but its proxy is sending traffic out with the real IP.
raise NoRealIpError("WARP proxy is leaking the real IP (warp=off); refusing OpenCode traffic")
last_exc: Exception | None = None
for attempt in range(3 if is_opencode_host else 1):
try:
return open_socks5_tunnel(clean_host, port, socks_host="127.0.0.1", socks_port=40000,
timeout=10.0 if is_opencode_host else 4.0)
except Exception as exc:
last_exc = exc
if attempt < 2:
time.sleep(1.0)
if is_opencode_host:
# Never send OpenCode out with the user's own IP: that IP is usually the one that already hit
# the free limit, so a new WARP IP would change nothing and the limit error would repeat.
raise NoRealIpError(
f"WARP proxy (port 40000) isn't answering ({type(last_exc).__name__}); "
"not sending OpenCode out with your own IP"
)
# 2. TUN mode or fallback: bind explicitly to the WARP adapter's IPv6
if is_opencode_host:
local_v6, pinned_edge = warp_state.get(wait_if_rotating=True)
if local_v6:
try:
return _open_pinned_v6(pinned_edge, port, local_v6)
except Exception:
pass
# Try local WARP SOCKS5 if TUN socket bind failed
try:
from tor_manager import open_socks5_tunnel
return open_socks5_tunnel(clean_host, port, socks_host="127.0.0.1", socks_port=40000, timeout=2.0)
except Exception:
pass
local_v6, _ = warp_state.get(wait_if_rotating=False)
if local_v6:
try:
infos = socket.getaddrinfo(clean_host, port, socket.AF_INET6, socket.SOCK_STREAM)
if infos:
return _open_pinned_v6(infos[0][4][0], port, local_v6)
except Exception:
pass
# 3. Resilient failover: If WARP is down, try active Tor before failing
try:
from tor_manager import get_active_tor_target, open_socks5_tunnel
tor_target = get_active_tor_target()
if tor_target:
return open_socks5_tunnel(clean_host, port, socks_host=tor_target[0], socks_port=tor_target[1], timeout=6.0)
except Exception:
pass
# 4. Strict fail-closed privacy mode: only fail if explicitly enabled by user
if is_strict:
raise ConnectionRefusedError("Cloudflare WARP tunnel unavailable (fail-closed strict mode)")
# 5. Resilient Direct Fallback:
# If WARP is unavailable or dropped, route directly so OpenCode NEVER throws 502/503 errors!
if is_opencode_host:
try:
_, pinned_edge = warp_state.get(wait_if_rotating=False)
if pinned_edge and ":" in pinned_edge:
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
sock.settimeout(3.0)
sock.connect((pinned_edge, port))
sock.settimeout(None)
return sock
except Exception:
pass
# Direct standard dual-stack connection (IPv4/IPv6)
sock = socket.create_connection((clean_host, port), timeout=8.0)
sock.settimeout(None)
return sock
def _open_upstream(
host: str,
port: int,
warp_state: _WarpState,
) -> socket.socket:
"""Connect upstream: supports WARP IPv6, Tor, and Custom SOCKS5/HTTP with resilient fallback."""
clean_host = host.strip("[]").lower()
if clean_host in ("127.0.0.1", "localhost", "::1"):
sock = socket.create_connection((clean_host, port), timeout=10.0)
sock.settimeout(None)
return sock
try:
from proxy_chain import get_egress_config, open_multi_egress_upstream
cfg = get_egress_config()
if cfg.get("mode") in ("tor", "custom"):
try:
return open_multi_egress_upstream(
host,
port,
lambda h, p: _open_warp_direct(h, p, warp_state),
)
except NoRealIpError:
raise
except Exception as exc:
is_strict = os.environ.get("OUC_STRICT_PROXY") == "1" or (LANE_DIR / "strict_proxy.flag").is_file()
if is_strict:
raise ConnectionRefusedError(f"Multi-egress ({cfg.get('mode')}) upstream error: {exc}")
# Fall back to resilient direct path if upstream proxy dropped
return _open_warp_direct(clean_host, port, warp_state)
except Exception:
pass
return _open_warp_direct(clean_host, port, warp_state)
def _make_handler(warp_state: _WarpState):
class ProxyHandler(socketserver.StreamRequestHandler):
def handle(self) -> None:
try:
raw_line = self.rfile.readline(65536)
except OSError:
return
if not raw_line:
return
parts = raw_line.decode("latin-1").strip().split()
if len(parts) < 3:
return
method, target, proto = parts[0].upper(), parts[1], parts[2]
headers: list[bytes] = []
content_len = 0
while True:
line = self.rfile.readline(65536)
if not line or line in (b"\r\n", b"\n"):
break
low = line.decode("latin-1").lower()
if low.startswith("proxy-connection:"):
continue
if low.startswith("content-length:"):
try:
content_len = int(low.split(":", 1)[1].strip())
except ValueError:
pass
headers.append(line)
if method == "CONNECT":
host, _, port_s = target.rpartition(":")
if not host:
host, port = target, 443
else:
try:
port = int(port_s)
except ValueError:
self._send_err(400, "Bad Request")
return
try:
upstream = _open_upstream(host, port, warp_state)
except Exception as exc:
if isinstance(exc, NoRealIpError):
_friendly_reason(host, exc, strict=True) # logs it
self._send_err(503, NO_REAL_IP_REASON)
return
if _is_strict():
self._send_err(503, _friendly_reason(host, exc, strict=True))
return
# Seamless direct fallback so user never gets 502/503 errors
try:
upstream = socket.create_connection((host, port), timeout=8.0)
upstream.settimeout(None)
except Exception as exc2:
self._send_err(503, _friendly_reason(host, exc2, strict=False))
return
try:
self.wfile.write(f"{proto} 200 Connection Established\r\n\r\n".encode("ascii"))
self.wfile.flush()
_relay(self.connection, upstream, watch_epoch=_is_opencode(host))
finally:
upstream.close()
return
parsed = urllib.parse.urlsplit(target)
host = parsed.hostname or ""
if not host:
self._send_err(400, "Bad Request")
return
port = parsed.port or (443 if parsed.scheme == "https" else 80)
path = parsed.path or "/"
if parsed.query:
path = f"{path}?{parsed.query}"
try:
upstream = _open_upstream(host, port, warp_state)
except Exception as exc:
if isinstance(exc, NoRealIpError):
_friendly_reason(host, exc, strict=True) # logs it
self._send_err(503, NO_REAL_IP_REASON)
return
if _is_strict():
self._send_err(503, _friendly_reason(host, exc, strict=True))
return
# Seamless direct fallback so user never gets 502/503 errors
try:
upstream = socket.create_connection((host, port), timeout=8.0)
upstream.settimeout(None)
except Exception as exc2:
self._send_err(503, _friendly_reason(host, exc2, strict=False))
return
try:
req_head = f"{method} {path} {proto}\r\n".encode("latin-1")
upstream.sendall(req_head)
for h in headers:
upstream.sendall(h)
upstream.sendall(b"\r\n")
if content_len > 0:
body = self.rfile.read(content_len)
if body:
upstream.sendall(body)
_relay(self.connection, upstream, watch_epoch=_is_opencode(host))
finally:
upstream.close()
def _send_err(self, code: int, reason: str) -> None:
try:
reason = " ".join(str(reason).split())[:220]
msg = f"HTTP/1.1 {code} {reason}\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
self.wfile.write(msg.encode("ascii", errors="replace"))
self.wfile.flush()
except OSError:
pass
return ProxyHandler
def start_proxy_server(port: int = 0) -> tuple[_ThreadedTCPServer, int, str]:
"""Start the local CONNECT proxy in a background thread and return (server, port, edge)."""
pool = fetch_opencode_aaaa_pool()
chosen_edge = os.environ.get("OUC_PIN_EDGE", "").strip() or random.choice(pool)
try:
ensure_dirs()
(LANE_DIR / "last_edge.txt").write_text(chosen_edge + "\n", encoding="utf-8")
except Exception:
pass
warp_state = _WarpState(pool=pool, initial_edge=chosen_edge, ttl=1.5)
handler = _make_handler(warp_state)
srv = _ThreadedTCPServer(("127.0.0.1", port), handler)
actual_port = srv.server_address[1]
t = threading.Thread(target=srv.serve_forever, daemon=True)
t.start()
_EPOCH["v"] = _file_epoch() # an old bump must not close the first tunnels
def _watch_controls() -> None:
while True:
time.sleep(1.0)
try:
warp_state.poll_controls()
except Exception:
pass
epoch = _file_epoch()
if epoch and epoch != _EPOCH["v"]:
_EPOCH["v"] = epoch
threading.Thread(target=_watch_controls, daemon=True).start()
return srv, actual_port, chosen_edge
if __name__ == "__main__":
bind_port = int(sys.argv[1]) if len(sys.argv) > 1 else 0
server, listening_port, edge = start_proxy_server(bind_port)
print(f"zen-proxy listening on 127.0.0.1:{listening_port} (edge={edge})", flush=True)
try:
threading.Event().wait()
except KeyboardInterrupt:
server.shutdown()
server.server_close()