mineconnect 1.0.0__tar.gz

mineconnect-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include requirements.txt
+recursive-include mineconnect *.yml
+recursive-include mineconnect *.json

mineconnect-1.0.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: mineconnect
+Version: 1.0.0
+Summary: Minecraft TCP/UDP to WebSocket bridge with Cloudflare tunnel support
+Author: MineConnect
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Requires-Dist: websockets>=12.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

mineconnect-1.0.0/README.md

@@ -0,0 +1,160 @@
+# MineConnect - Installation & Usage
+
+A Python module for bridging Minecraft Java and Bedrock connections through WebSocket to Cloudflare tunnels.
+
+## Installation
+
+### From Source (Development)
+
+```bash
+cd c:\Projects\MineConnect\server
+pip install -e .
+```
+
+### From PyPI (Future)
+
+```bash
+pip install mineconnect
+```
+
+## One-Time Setup
+
+Before using MineConnect, run the tunnel setup (requires cloudflared installed):
+
+```bash
+mineconnect-setup
+```
+
+Or:
+
+```bash
+python -m mineconnect.tunnel_setup
+```
+
+This will:
+1. Authenticate with Cloudflare
+2. Create two tunnels (java and bedrock)
+3. Configure DNS routing
+4. Update configuration files
+
+## Usage
+
+### Simple API
+
+```python
+from mineconnect import mcs
+
+# Use default ports (25565 for Java, 19132 for Bedrock)
+session = mcs.config()
+session.start()
+```
+
+### Custom Ports
+
+```python
+from mineconnect import mcs
+
+# Custom Minecraft server ports
+session = mcs.config(tcp_port=25566, udp_port=19133)
+session.start()
+```
+
+### Single Tunnel Mode
+
+```python
+from mineconnect import mcs
+
+# Use one tunnel with two ingress rules instead of two separate tunnels
+session = mcs.config(tcp_port=25565, udp_port=19132, single_tunnel=True)
+session.start()
+```
+
+### Full Example
+
+```python
+from mineconnect import mcs
+
+def main():
+    # Configure server with custom ports
+    session = mcs.config(
+        tcp_port=25565,      # Minecraft Java Edition port
+        udp_port=19132,      # Geyser/Bedrock port
+        single_tunnel=False  # Use two separate tunnels
+    )
+    
+    # Start server - blocks and shows logs until Ctrl+C
+    try:
+        session.start()
+    except KeyboardInterrupt:
+        print("Server stopped by user")
+
+if __name__ == "__main__":
+    main()
+```
+
+## Parameters
+
+### `mcs.config(tcp_port, udp_port, single_tunnel)`
+
+- **tcp_port** (int, default: 25565): Port where your Minecraft Java Edition server is running
+- **udp_port** (int, default: 19132): Port where your Geyser/Bedrock server is running  
+- **single_tunnel** (bool, default: False): Use single tunnel with two ingress rules instead of two separate tunnels
+
+### `session.start()`
+
+Starts all services:
+- TCP WebSocket bridge (port 8764)
+- UDP WebSocket bridge (port 8765)
+- Cloudflared tunnel(s)
+
+Logs are displayed in real-time. Press Ctrl+C to stop all services gracefully.
+
+## Prerequisites
+
+1. **Python 3.8+**
+2. **cloudflared**: Install from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/
+3. **Minecraft Java Server**: Running on specified tcp_port (default: localhost:25565)
+4. **Geyser** (for Bedrock support): Running on specified udp_port (default: localhost:19132)
+
+## Architecture
+
+```
+Minecraft Client → Cloudflare Tunnel → WebSocket Bridge → Local MC Server
+```
+
+- **TCP Bridge**: Handles Java Edition connections via persistent WebSocket
+- **UDP Bridge**: Handles Bedrock Edition connections via WebSocket
+- **Cloudflared**: Creates secure tunnels from Cloudflare edge to local bridges
+
+## Troubleshooting
+
+### "Cannot start TCP-WS-Bridge" or "Cannot start UDP-WS-Bridge"
+
+Make sure the websockets package is installed:
+```bash
+pip install websockets
+```
+
+### "Cannot reach MC" errors
+
+Ensure your Minecraft server is running on the configured port before starting MineConnect.
+
+### Cloudflared not found
+
+Install cloudflared and make sure it's in your PATH:
+- Windows: Download from Cloudflare and add to PATH
+- Linux: `wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64`
+- macOS: `brew install cloudflared`
+
+## Development
+
+To modify the package:
+
+1. Clone the repository
+2. Install in editable mode: `pip install -e server/`
+3. Make changes to files in `server/mineconnect/`
+4. Changes take effect immediately
+
+## License
+
+MIT License

mineconnect-1.0.0/mineconnect/__init__.py

@@ -0,0 +1,44 @@
+"""
+MineConnect - Minecraft Server Connection Bridge
+
+Simple API for bridging Minecraft Java and Bedrock connections through 
+WebSocket to Cloudflare tunnels.
+
+Usage:
+    from mineconnect import mcs
+    
+    session = mcs.config(tcp_port=25565, udp_port=19132, single_tunnel=False)
+    session.start()
+"""
+
+from .server import MineConnectServer
+
+__version__ = "1.0.0"
+__all__ = ["MineConnectServer", "mcs"]
+
+
+class _MCS:
+    """Simple configuration wrapper for MineConnect."""
+    
+    @staticmethod
+    def config(tcp_port=25565, udp_port=19132, single_tunnel=False):
+        """
+        Configure a MineConnect server session.
+        
+        Args:
+            tcp_port (int): Minecraft Java Edition server port (default: 25565)
+            udp_port (int): Geyser/Bedrock server port (default: 19132)
+            single_tunnel (bool): Use single tunnel with two ingress rules (default: False)
+            
+        Returns:
+            MineConnectServer: Configured server instance
+        """
+        return MineConnectServer(
+            tcp_port=tcp_port,
+            udp_port=udp_port,
+            single_tunnel=single_tunnel
+        )
+
+
+# Export the main API
+mcs = _MCS()

mineconnect-1.0.0/mineconnect/creds/d75d9307-b76a-410d-9692-16c3cd0926b7.json

@@ -0,0 +1 @@
+{"AccountTag":"7b8aa8d0e13cb1182b8c73cd58bd2b6c","TunnelSecret":"Tzu9w16Q40cmcBD11Yc0Rj8Bv9EOdDiwH1436kRe9nk=","TunnelID":"d75d9307-b76a-410d-9692-16c3cd0926b7","Endpoint":""}

mineconnect-1.0.0/mineconnect/creds/f06e9c55-aab2-455b-81d5-08423eb92a39.json

@@ -0,0 +1 @@
+{"AccountTag":"7b8aa8d0e13cb1182b8c73cd58bd2b6c","TunnelSecret":"TvzSIyTh1nveCeMlj3SdEOlQ3WxxxlGFApqAeIkRhtE=","TunnelID":"f06e9c55-aab2-455b-81d5-08423eb92a39","Endpoint":""}

mineconnect-1.0.0/mineconnect/server.py

@@ -0,0 +1,184 @@
+"""
+MineConnect Server — Main server orchestration class
+"""
+
+import subprocess
+import sys
+import os
+import time
+import signal
+import threading
+import logging
+from typing import Optional, List, Tuple
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+)
+
+
+class MineConnectServer:
+    """
+    Main server class that orchestrates TCP/UDP bridges and cloudflared tunnels.
+    
+    Usage:
+        server = MineConnectServer(tcp_port=25565, udp_port=19132)
+        server.start()  # Blocks until stopped with Ctrl+C
+    """
+    
+    def __init__(self, tcp_port: int = 25565, udp_port: int = 19132, 
+                 single_tunnel: bool = False, ws_tcp_port: int = 8764, 
+                 ws_udp_port: int = 8765):
+        """
+        Initialize MineConnect server configuration.
+        
+        Args:
+            tcp_port: Minecraft Java Edition server port (default: 25565)
+            udp_port: Geyser/Bedrock server port (default: 19132)
+            single_tunnel: Use one tunnel with two ingress rules (default: False)
+            ws_tcp_port: WebSocket port for TCP bridge (default: 8764)
+            ws_udp_port: WebSocket port for UDP bridge (default: 8765)
+        """
+        self.tcp_port = tcp_port
+        self.udp_port = udp_port
+        self.single_tunnel = single_tunnel
+        self.ws_tcp_port = ws_tcp_port
+        self.ws_udp_port = ws_udp_port
+        
+        self.logger = logging.getLogger("mineconnect-server")
+        self._children: List[Tuple[str, subprocess.Popen]] = []
+        self._running = False
+        
+        # Get package directory for config files
+        self.package_dir = os.path.dirname(os.path.abspath(__file__))
+        
+    def _launch(self, name: str, cmd: List[str], cwd: Optional[str] = None) -> Optional[subprocess.Popen]:
+        """Launch a subprocess and attach logging."""
+        self.logger.info("Starting %s: %s", name, " ".join(cmd))
+        try:
+            proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                cwd=cwd,
+            )
+        except FileNotFoundError as exc:
+            self.logger.error("Cannot start %s: %s", name, exc)
+            return None
+
+        self._children.append((name, proc))
+
+        def _reader():
+            for line in proc.stdout:
+                self.logger.info("[%s] %s", name, line.rstrip())
+
+        threading.Thread(target=_reader, daemon=True).start()
+        return proc
+
+    def _shutdown(self, *_):
+        """Gracefully shutdown all services."""
+        if not self._running:
+            return
+            
+        self.logger.info("Shutting down all services…")
+        self._running = False
+        
+        for name, proc in self._children:
+            self.logger.info("  Stopping %s", name)
+            proc.terminate()
+            
+        for name, proc in self._children:
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                
+        self._children.clear()
+
+    def start(self):
+        """
+        Start the MineConnect server with all bridges and tunnels.
+        
+        This method blocks until interrupted with Ctrl+C or terminated.
+        Logs are displayed to the console in real-time.
+        """
+        self.logger.info("=" * 60)
+        self.logger.info("  MineConnect Server Starting")
+        self.logger.info("  TCP Port: %d | UDP Port: %d", self.tcp_port, self.udp_port)
+        self.logger.info("  Single Tunnel Mode: %s", self.single_tunnel)
+        self.logger.info("=" * 60)
+        
+        # Register signal handlers
+        signal.signal(signal.SIGINT, self._shutdown)
+        signal.signal(signal.SIGTERM, self._shutdown)
+        
+        self._running = True
+        py = sys.executable
+
+        try:
+            # 1) TCP<->WS bridge for Java Edition
+            tcp_bridge_path = os.path.join(self.package_dir, "tcp_bridge.py")
+            self._launch("TCP-WS-Bridge", [
+                py, tcp_bridge_path,
+                "--ws-port", str(self.ws_tcp_port),
+                "--mc-port", str(self.tcp_port),
+            ])
+
+            # 2) UDP<->WS bridge for Bedrock Edition
+            udp_bridge_path = os.path.join(self.package_dir, "udp_bridge.py")
+            self._launch("UDP-WS-Bridge", [
+                py, udp_bridge_path,
+                "--ws-port", str(self.ws_udp_port),
+                "--geyser-port", str(self.udp_port),
+            ])
+
+            time.sleep(1)  # Let bridges initialize
+
+            # 3) Cloudflared tunnel(s)
+            # Run from package directory where configs and creds are located
+            if self.single_tunnel:
+                cfg = os.path.join(self.package_dir, "tunnel_combined.yml")
+                self._launch("Cloudflared", ["cloudflared", "tunnel", "--config", cfg, "run"], cwd=self.package_dir)
+            else:
+                java_cfg = os.path.join(self.package_dir, "tunnel_java.yml")
+                bedrock_cfg = os.path.join(self.package_dir, "tunnel_bedrock.yml")
+                
+                self._launch("Cloudflared-Java", [
+                    "cloudflared", "tunnel",
+                    "--config", java_cfg,
+                    "run",
+                ], cwd=self.package_dir)
+                self._launch("Cloudflared-Bedrock", [
+                    "cloudflared", "tunnel",
+                    "--config", bedrock_cfg,
+                    "run",
+                ], cwd=self.package_dir)
+
+            self.logger.info("=" * 60)
+            self.logger.info("  All services running. Press Ctrl+C to stop.")
+            self.logger.info("=" * 60)
+
+            # Monitor processes
+            while self._running:
+                for name, proc in self._children:
+                    if proc.poll() is not None:
+                        self.logger.warning("%s exited (code %s)", name, proc.returncode)
+                        if self._running:
+                            self.logger.error("Service crashed! Initiating shutdown...")
+                            self._shutdown()
+                            break
+                time.sleep(2)
+                
+        except Exception as exc:
+            self.logger.error("Fatal error: %s", exc)
+            self._shutdown()
+            raise
+        finally:
+            if self._running:
+                self._shutdown()
+            self.logger.info("MineConnect server stopped.")
+
+    def stop(self):
+        """Manually stop the server."""
+        self._shutdown()

mineconnect-1.0.0/mineconnect/tcp_bridge.py

@@ -0,0 +1,161 @@
+"""
+TCP <-> WebSocket Bridge for Minecraft Java Edition
+
+Runs a WebSocket server. The client keeps a persistent WebSocket and
+sends framed messages:
+  0x01 + data = new TCP session to MC (+ first chunk)
+  0x02 + data = data for current session
+  0x03        = close current session
+
+The bridge opens/closes TCP connections to the MC server accordingly.
+
+Flow:
+  MC Java Client -> [Client Tunnel] -> persistent WS -> [This Bridge] -> TCP -> MC Server
+"""
+
+import asyncio
+import logging
+import argparse
+
+try:
+    import websockets
+except ImportError:
+    raise SystemExit("Install websockets: pip install websockets")
+
+logger = logging.getLogger("tcp-ws-bridge")
+
+MSG_NEW   = b'\x01'
+MSG_DATA  = b'\x02'
+MSG_CLOSE = b'\x03'
+
+
+async def handle_connection(websocket, mc_host: str, mc_port: int):
+    """Handle persistent WS from client tunnel, manage TCP sessions to MC."""
+    peer = websocket.remote_address
+    logger.info("Client tunnel connected: %s", peer)
+
+    reader = None
+    writer = None
+    tcp_read_task = None
+
+    async def _close_tcp():
+        nonlocal reader, writer, tcp_read_task
+        if tcp_read_task and not tcp_read_task.done():
+            tcp_read_task.cancel()
+            tcp_read_task = None
+        if writer:
+            try:
+                writer.close()
+            except OSError:
+                pass
+        reader = None
+        writer = None
+
+    async def _tcp_reader():
+        """Read from MC server TCP and send back over WS."""
+        nonlocal reader
+        try:
+            while reader:
+                data = await reader.read(65536)
+                if not data:
+                    break
+                await websocket.send(MSG_DATA + data)
+        except (ConnectionResetError, asyncio.CancelledError, OSError):
+            pass
+        except websockets.ConnectionClosed:
+            pass
+
+    try:
+        async for message in websocket:
+            if isinstance(message, str):
+                message = message.encode("utf-8")
+            if not message:
+                continue
+
+            msg_type = message[0:1]
+            payload = message[1:]
+
+            if msg_type == MSG_NEW:
+                # Close any existing session
+                await _close_tcp()
+
+                # Open new TCP to MC server
+                try:
+                    reader, writer = await asyncio.open_connection(mc_host, mc_port)
+                    logger.info("New TCP session to %s:%s for %s", mc_host, mc_port, peer)
+                except (ConnectionRefusedError, OSError) as exc:
+                    logger.error("Cannot reach MC: %s", exc)
+                    await websocket.send(MSG_CLOSE)
+                    continue
+
+                # Start reading TCP responses
+                tcp_read_task = asyncio.ensure_future(_tcp_reader())
+
+                # Forward the first chunk
+                if payload:
+                    writer.write(payload)
+                    await writer.drain()
+
+            elif msg_type == MSG_DATA:
+                if writer:
+                    try:
+                        writer.write(payload)
+                        await writer.drain()
+                    except (ConnectionResetError, OSError):
+                        await _close_tcp()
+                        await websocket.send(MSG_CLOSE)
+
+            elif msg_type == MSG_CLOSE:
+                logger.info("Client closed TCP session for %s", peer)
+                await _close_tcp()
+
+    except websockets.ConnectionClosed:
+        logger.info("Client tunnel disconnected: %s", peer)
+    except Exception as exc:
+        logger.error("Bridge error for %s: %s", peer, exc)
+    finally:
+        await _close_tcp()
+        logger.info("Session ended for %s", peer)
+
+
+async def run_bridge(ws_host: str, ws_port: int, mc_host: str, mc_port: int):
+    """Main bridge coroutine."""
+    logger.info(
+        "TCP<->WS Bridge: ws://%s:%s <-> tcp://%s:%s",
+        ws_host, ws_port, mc_host, mc_port,
+    )
+
+    async with websockets.serve(
+        lambda ws: handle_connection(ws, mc_host, mc_port),
+        ws_host,
+        ws_port,
+        max_size=None,
+        ping_interval=20,
+        ping_timeout=30,
+    ):
+        logger.info("Bridge ready – waiting for connections…")
+        await asyncio.Future()  # run forever
+
+
+def main():
+    """CLI entry point."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+    )
+    
+    parser = argparse.ArgumentParser(description="TCP<->WS Bridge for MC Java")
+    parser.add_argument("--ws-host", default="127.0.0.1")
+    parser.add_argument("--ws-port", type=int, default=8764)
+    parser.add_argument("--mc-host", default="127.0.0.1")
+    parser.add_argument("--mc-port", type=int, default=25565)
+    args = parser.parse_args()
+
+    try:
+        asyncio.run(run_bridge(args.ws_host, args.ws_port, args.mc_host, args.mc_port))
+    except KeyboardInterrupt:
+        logger.info("Shutting down…")
+
+
+if __name__ == "__main__":
+    main()

mineconnect-1.0.0/mineconnect/tunnel_bedrock.yml

@@ -0,0 +1,10 @@
+# Cloudflared tunnel config – Bedrock Edition (UDP via WS bridge)
+# Replace TUNNEL_ID_HERE after running setup_tunnels.py
+
+tunnel: d75d9307-b76a-410d-9692-16c3cd0926b7
+credentials-file: ./creds/d75d9307-b76a-410d-9692-16c3cd0926b7.json
+
+ingress:
+  - hostname: bedrock.ideadev.me
+    service: http://localhost:8765
+  - service: http_status:404

mineconnect-1.0.0/mineconnect/tunnel_combined.yml

@@ -0,0 +1,13 @@
+# Cloudflared tunnel config – Combined (single tunnel, both editions)
+# Use with:  python start_server.py --single-tunnel
+# Replace TUNNEL_ID_HERE after running setup_tunnels.py
+
+tunnel: TUNNEL_ID_HERE
+credentials-file: ~/.cloudflared/TUNNEL_ID_HERE.json
+
+ingress:
+  - hostname: java.ideadev.me
+    service: http://localhost:8764
+  - hostname: bedrock.ideadev.me
+    service: http://localhost:8765
+  - service: http_status:404

mineconnect-1.0.0/mineconnect/tunnel_java.yml

@@ -0,0 +1,10 @@
+# Cloudflared tunnel config – Java Edition (TCP via WS bridge)
+# Replace TUNNEL_ID_HERE after running setup_tunnels.py
+
+tunnel: f06e9c55-aab2-455b-81d5-08423eb92a39
+credentials-file: ./creds/f06e9c55-aab2-455b-81d5-08423eb92a39.json
+
+ingress:
+  - hostname: java.ideadev.me
+    service: http://localhost:8764
+  - service: http_status:404

mineconnect-1.0.0/mineconnect/tunnel_setup.py

@@ -0,0 +1,99 @@
+"""
+One-time setup for MineConnect cloudflared tunnels.
+
+Creates two named tunnels, routes DNS to ideadev.me subdomains,
+and patches the YAML config files with the real tunnel IDs.
+
+Usage:
+    mineconnect-setup  # After pip install
+    OR
+    python -m mineconnect.tunnel_setup
+"""
+
+import subprocess
+import os
+import sys
+import json
+
+DOMAIN = "ideadev.me"
+
+
+def _run(cmd, check=False):
+    print(f"  $ {' '.join(cmd)}")
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    out = (result.stdout + result.stderr).strip()
+    if out:
+        for line in out.splitlines():
+            print(f"    {line}")
+    if check and result.returncode != 0:
+        sys.exit(f"Command failed (exit {result.returncode})")
+    return result
+
+
+def _patch_config(config_dir, filename, tunnel_id):
+    path = os.path.join(config_dir, filename)
+    if not os.path.exists(path):
+        return
+    with open(path, "r", encoding="utf-8") as fh:
+        text = fh.read()
+    text = text.replace("TUNNEL_ID_HERE", tunnel_id)
+    with open(path, "w", encoding="utf-8") as fh:
+        fh.write(text)
+    print(f"  -> Updated {filename}")
+
+
+def main():
+    print("=" * 56)
+    print("  MineConnect  —  Tunnel Setup")
+    print("=" * 56)
+
+    # Get config directory (parent of package)
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+    config_dir = os.path.dirname(package_dir)
+
+    # 1 — Login
+    print("\n[1/5] Cloudflare authentication")
+    print("  A browser window will open — please log in.")
+    _run(["cloudflared", "tunnel", "login"])
+
+    # 2 — Create tunnels
+    for name in ("mineconnect-java", "mineconnect-bedrock"):
+        print(f"\n[2/5] Creating tunnel: {name}")
+        _run(["cloudflared", "tunnel", "create", name])
+
+    # 3 — DNS routing
+    print(f"\n[3/5] Routing java.{DOMAIN}")
+    _run([
+        "cloudflared", "tunnel", "route", "dns",
+        "mineconnect-java", f"java.{DOMAIN}",
+    ])
+
+    print(f"\n[4/5] Routing bedrock.{DOMAIN}")
+    _run([
+        "cloudflared", "tunnel", "route", "dns",
+        "mineconnect-bedrock", f"bedrock.{DOMAIN}",
+    ])
+
+    # 4 — Patch config files with real tunnel IDs
+    print("\n[5/5] Updating config files")
+    result = _run(["cloudflared", "tunnel", "list", "-o", "json"])
+    if result.stdout:
+        try:
+            tunnels = json.loads(result.stdout)
+            for t in tunnels:
+                name = t.get("name", "")
+                tid = t.get("id", "")
+                if name == "mineconnect-java":
+                    _patch_config(config_dir, "tunnel_java.yml", tid)
+                elif name == "mineconnect-bedrock":
+                    _patch_config(config_dir, "tunnel_bedrock.yml", tid)
+        except json.JSONDecodeError:
+            print("  !! Could not parse tunnel list — edit configs manually.")
+
+    print("\n" + "=" * 56)
+    print("  Setup complete!")
+    print("=" * 56)
+
+
+if __name__ == "__main__":
+    main()

mineconnect-1.0.0/mineconnect/udp_bridge.py

@@ -0,0 +1,112 @@
+"""
+UDP <-> WebSocket Bridge for Minecraft Bedrock Edition (Geyser)
+
+Runs a WebSocket server. Each incoming WebSocket connection gets its own
+UDP socket to communicate with Geyser. Packets are relayed bidirectionally.
+
+Flow:
+  Bedrock Client -> [Client Bridge] -> WebSocket -> [This Bridge] -> UDP -> Geyser
+"""
+
+import asyncio
+import logging
+import argparse
+
+try:
+    import websockets
+except ImportError:
+    raise SystemExit("Install websockets: pip install websockets")
+
+logger = logging.getLogger("udp-ws-bridge")
+
+
+class GeyserRelay(asyncio.DatagramProtocol):
+    """Relays UDP responses from Geyser back through the WebSocket."""
+
+    def __init__(self, websocket):
+        self.websocket = websocket
+        self.transport = None
+
+    def connection_made(self, transport):
+        self.transport = transport
+
+    def datagram_received(self, data, addr):
+        asyncio.ensure_future(self._forward(data))
+
+    async def _forward(self, data):
+        try:
+            await self.websocket.send(data)
+        except websockets.ConnectionClosed:
+            pass
+
+    def error_received(self, exc):
+        logger.warning("UDP error: %s", exc)
+
+
+async def handle_connection(websocket, geyser_host: str, geyser_port: int):
+    """Bridge one WebSocket client to Geyser over UDP."""
+    peer = websocket.remote_address
+    logger.info("New WebSocket client: %s", peer)
+
+    loop = asyncio.get_event_loop()
+    transport, protocol = await loop.create_datagram_endpoint(
+        lambda: GeyserRelay(websocket),
+        remote_addr=(geyser_host, geyser_port),
+    )
+
+    try:
+        async for message in websocket:
+            if isinstance(message, str):
+                message = message.encode("utf-8")
+            if isinstance(message, bytes):
+                transport.sendto(message)
+    except websockets.ConnectionClosed:
+        logger.info("Client %s disconnected", peer)
+    except Exception as exc:
+        logger.error("Bridge error for %s: %s", peer, exc)
+    finally:
+        transport.close()
+        logger.info("Relay closed for %s", peer)
+
+
+async def run_bridge(ws_host: str, ws_port: int, geyser_host: str, geyser_port: int):
+    """Main bridge coroutine."""
+    logger.info(
+        "UDP<->WS Bridge: ws://%s:%s <-> udp://%s:%s",
+        ws_host, ws_port, geyser_host, geyser_port,
+    )
+
+    async with websockets.serve(
+        lambda ws: handle_connection(ws, geyser_host, geyser_port),
+        ws_host,
+        ws_port,
+        max_size=None,
+        ping_interval=20,
+        ping_timeout=30,
+    ):
+        logger.info("Bridge ready – waiting for connections…")
+        await asyncio.Future()  # run forever
+
+
+def main():
+    """CLI entry point."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+    )
+    
+    parser = argparse.ArgumentParser(description="UDP<->WS Bridge for Geyser")
+    parser.add_argument("--ws-host", default="127.0.0.1")
+    parser.add_argument("--ws-port", type=int, default=8765)
+    parser.add_argument("--geyser-host", default="127.0.0.1")
+    parser.add_argument("--geyser-port", type=int, default=19132)
+    args = parser.parse_args()
+
+    try:
+        asyncio.run(run_bridge(args.ws_host, args.ws_port, args.geyser_host, args.geyser_port))
+    except KeyboardInterrupt:
+        logger.info("Shutting down…")
+
+
+if __name__ == "__main__":
+    main()

mineconnect-1.0.0/mineconnect.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: mineconnect
+Version: 1.0.0
+Summary: Minecraft TCP/UDP to WebSocket bridge with Cloudflare tunnel support
+Author: MineConnect
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Requires-Dist: websockets>=12.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

mineconnect-1.0.0/mineconnect.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+MANIFEST.in
+README.md
+requirements.txt
+setup.py
+mineconnect/__init__.py
+mineconnect/server.py
+mineconnect/tcp_bridge.py
+mineconnect/tunnel_bedrock.yml
+mineconnect/tunnel_combined.yml
+mineconnect/tunnel_java.yml
+mineconnect/tunnel_setup.py
+mineconnect/udp_bridge.py
+mineconnect.egg-info/PKG-INFO
+mineconnect.egg-info/SOURCES.txt
+mineconnect.egg-info/dependency_links.txt
+mineconnect.egg-info/entry_points.txt
+mineconnect.egg-info/requires.txt
+mineconnect.egg-info/top_level.txt
+mineconnect/creds/d75d9307-b76a-410d-9692-16c3cd0926b7.json
+mineconnect/creds/f06e9c55-aab2-455b-81d5-08423eb92a39.json

mineconnect-1.0.0/mineconnect.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mineconnect-1.0.0/mineconnect.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mineconnect-setup = mineconnect.tunnel_setup:main

mineconnect-1.0.0/mineconnect.egg-info/requires.txt

@@ -0,0 +1 @@
+websockets>=12.0

mineconnect-1.0.0/mineconnect.egg-info/top_level.txt

@@ -0,0 +1 @@
+mineconnect

mineconnect-1.0.0/requirements.txt

@@ -0,0 +1 @@
+websockets>=12.0

mineconnect-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mineconnect-1.0.0/setup.py

@@ -0,0 +1,34 @@
+"""
+MineConnect - Minecraft TCP/UDP to WebSocket Bridge with Cloudflare Tunnels
+"""
+
+from setuptools import setup, find_packages
+
+with open("requirements.txt", "r", encoding="utf-8") as f:
+    requirements = [line.strip() for line in f if line.strip() and not line.startswith("#")]
+
+setup(
+    name="mineconnect",
+    version="1.0.0",
+    description="Minecraft TCP/UDP to WebSocket bridge with Cloudflare tunnel support",
+    author="MineConnect",
+    packages=find_packages(),
+    install_requires=requirements,
+    python_requires=">=3.8",
+    entry_points={
+        "console_scripts": [
+            "mineconnect-setup=mineconnect.tunnel_setup:main",
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+    package_data={
+        "mineconnect": ["*.yml", "creds/*.json"],
+    },
+    include_package_data=True,
+)