atunnel 1.0.0__tar.gz

atunnel-1.0.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: atunnel
+Version: 1.0.0
+Summary: A-tunnel is a tool to expose localhost to the public internet using Cloudflare Quick Tunnels
+Author-email: Abodx9 <abodx@gmx.de>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Abodx9/A-tunnel
+Keywords: cloudflare,tunnel,localhost,expose,public
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# A-tunnel
+A minimal Python package to expose localhost to the public internet using [Cloudflare Quick Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/).
+
+No Cloudflare account required  generates a temporary `*.trycloudflare.com` URL.
+
+## Installation
+
+```bash
+# Using pip
+pip install atunnel
+
+# Or using uv
+uv add atunnel
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Expose local port 8080
+atunnel --port 8080
+
+# With uv
+uv run atunnel --port 8080
+```
+
+The public URL is printed to stdout. Press Ctrl+C to stop.
+
+### Python API
+
+```python
+from atunnel.tunnel import Tunnel
+
+with Tunnel(port=8080) as t:
+    print(f"Public URL: {t.public_url}")
+    input("Press Enter to stop...")

atunnel-1.0.0/README.md

@@ -0,0 +1,37 @@
+# A-tunnel
+A minimal Python package to expose localhost to the public internet using [Cloudflare Quick Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/).
+
+No Cloudflare account required  generates a temporary `*.trycloudflare.com` URL.
+
+## Installation
+
+```bash
+# Using pip
+pip install atunnel
+
+# Or using uv
+uv add atunnel
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Expose local port 8080
+atunnel --port 8080
+
+# With uv
+uv run atunnel --port 8080
+```
+
+The public URL is printed to stdout. Press Ctrl+C to stop.
+
+### Python API
+
+```python
+from atunnel.tunnel import Tunnel
+
+with Tunnel(port=8080) as t:
+    print(f"Public URL: {t.public_url}")
+    input("Press Enter to stop...")

atunnel-1.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "atunnel"
+version = "1.0.0"
+description = "A-tunnel is a tool to expose localhost to the public internet using Cloudflare Quick Tunnels"
+readme = "README.md"
+license = "MIT"
+authors = [
+    {name = "Abodx9", email = "abodx@gmx.de"},
+]
+requires-python = ">=3.9"
+keywords = ["cloudflare", "tunnel", "localhost", "expose", "public"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet",
+]
+
+[project.urls]
+Repository = "https://github.com/Abodx9/A-tunnel"
+
+
+[project.scripts]
+atunnel = "atunnel.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["atunnel*"]

atunnel-1.0.0/setup.cfg

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

atunnel-1.0.0/src/atunnel/__init__.py

@@ -0,0 +1,9 @@
+"""
+atunnel: A minimal Python package to expose localhost to the public internet
+using Cloudflare's cloudflared tunnel (quick tunnels).
+"""
+
+from atunnel.tunnel import Tunnel
+
+__all__ = ["Tunnel"]
+__version__ = "1.0.0"

atunnel-1.0.0/src/atunnel/__main__.py

@@ -0,0 +1,9 @@
+"""Run atunnel with ``uv run atunnel``."""
+
+import sys
+
+from atunnel.cli import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

atunnel-1.0.0/src/atunnel/binary.py

@@ -0,0 +1,135 @@
+"""
+Downloads and manages the cloudflared binary for the current platform.
+"""
+
+import os
+import platform
+import shutil
+import stat
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+
+_GITHUB_RELEASES_BASE = (
+    "https://github.com/cloudflare/cloudflared/releases/latest/download"
+)
+
+_BINARY_MAP = {
+    ("Linux", "x86_64"): "cloudflared-linux-amd64",
+    ("Linux", "aarch64"): "cloudflared-linux-arm64",
+    ("Linux", "armv7l"): "cloudflared-linux-arm",
+    ("Darwin", "x86_64"): "cloudflared-darwin-amd64.tgz",
+    ("Darwin", "arm64"): "cloudflared-darwin-arm64.tgz",
+    ("Windows", "AMD64"): "cloudflared-windows-amd64.exe",
+}
+
+
+def _cache_dir() -> Path:
+    """Return the package-local directory for downloaded binaries."""
+    override = os.environ.get("ATUNNEL_BIN_DIR")
+    if override:
+        return Path(override).expanduser()
+
+    return Path(__file__).parent / "bin"
+
+
+def _binary_name() -> str:
+    if platform.system() == "Windows":
+        return "cloudflared.exe"
+    return "cloudflared"
+
+
+def find_binary() -> Optional[Path]:
+    """Find an existing cloudflared binary (cache or PATH)."""
+    cached = _cache_dir() / _binary_name()
+    if cached.exists():
+        return cached
+    system_bin = shutil.which("cloudflared")
+    if system_bin:
+        return Path(system_bin)
+    return None
+
+
+def ensure_binary() -> Path:
+    """Return path to cloudflared binary, downloading if necessary."""
+    existing = find_binary()
+    if existing:
+        return existing
+    return download()
+
+
+def download() -> Path:
+    """Download the cloudflared binary for the current platform."""
+    system = platform.system()
+    machine = platform.machine()
+    filename = _BINARY_MAP.get((system, machine))
+
+    if filename is None:
+        raise RuntimeError(
+            f"Unsupported platform: {system} {machine}. "
+            f"Supported: {list(_BINARY_MAP.keys())}"
+        )
+
+    url = f"{_GITHUB_RELEASES_BASE}/{filename}"
+    cache = _cache_dir()
+    cache.mkdir(parents=True, exist_ok=True)
+    dest = cache / _binary_name()
+
+    print("Initializing for the first run...", file=sys.stderr)
+
+    if filename.endswith(".tgz"):
+        _download_tgz(url, dest)
+    else:
+        _download_file(url, dest)
+
+    if system != "Windows":
+        dest.chmod(dest.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    return dest
+
+
+def _download_file(url: str, dest: Path) -> None:
+    tmp_fd, tmp_path = tempfile.mkstemp(dir=dest.parent, suffix=".download")
+    try:
+        os.close(tmp_fd)
+        req = urllib.request.Request(url, headers={"User-Agent": "atunnel/1.0"})
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            with open(tmp_path, "wb") as f:
+                shutil.copyfileobj(resp, f)
+        shutil.move(tmp_path, dest)
+    except Exception:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def _download_tgz(url: str, dest: Path) -> None:
+    import tarfile
+
+    tmp_fd, tmp_path = tempfile.mkstemp(dir=dest.parent, suffix=".tgz")
+    try:
+        os.close(tmp_fd)
+        req = urllib.request.Request(url, headers={"User-Agent": "atunnel/1.0"})
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            with open(tmp_path, "wb") as f:
+                shutil.copyfileobj(resp, f)
+
+        with tarfile.open(tmp_path, "r:gz") as tar:
+            for member in tar.getnames():
+                if "cloudflared" in member and not member.endswith("/"):
+                    extracted = tar.extractfile(member)
+                    if extracted:
+                        with open(dest, "wb") as f:
+                            shutil.copyfileobj(extracted, f)
+                        return
+            raise RuntimeError("cloudflared binary not found in archive")
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass

atunnel-1.0.0/src/atunnel/cli.py

@@ -0,0 +1,163 @@
+"""
+CLI entry point for atunnel.
+
+Usage:
+    atunnel --port 8080
+"""
+
+import argparse
+import os
+import socket
+import signal
+import sys
+from importlib.metadata import PackageNotFoundError, version
+
+from atunnel import __version__
+from atunnel.tunnel import Tunnel
+
+
+_RESET = "\033[0m"
+_BOLD = "\033[1m"
+_WHITE = "\033[97m"
+_CYAN = "\033[36m"
+_DIM = "\033[2m"
+_GREEN = "\033[32m"
+_YELLOW = "\033[33m"
+_RED = "\033[31m"
+
+
+def _installed_version() -> str:
+    try:
+        return version("atunnel")
+    except PackageNotFoundError:
+        return __version__
+
+
+def _color(text: str, *styles: str) -> str:
+    if not sys.stderr.isatty() or "NO_COLOR" in os.environ:
+        return text
+    return f"{''.join(styles)}{text}{_RESET}"
+
+
+def _print_panel() -> None:
+    lines = [
+        "A-tunnel — Fast way to expose your apps to the internet",
+        "               Made by Abodx",
+    ]
+    width = max(len(line) for line in lines) + 2
+    border = _color("+" + "-" * width + "+", _CYAN)
+    print(border, file=sys.stderr)
+    print(
+        _color("| ", _CYAN)
+        + _color(lines[0].ljust(width - 2), _BOLD, _WHITE)
+        + _color(" |", _CYAN),
+        file=sys.stderr,
+    )
+    print(
+        _color("| ", _CYAN)
+        + _color(lines[1].ljust(width - 2), _DIM)
+        + _color(" |", _CYAN),
+        file=sys.stderr,
+    )
+    print(border, file=sys.stderr)
+
+
+def _local_server_exists(host: str, port: int, timeout: float = 1.0) -> bool:
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            return True
+    except OSError:
+        return False
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        prog="atunnel",
+        description="Expose a local port to the internet via Cloudflare Quick Tunnels.",
+    )
+    parser.add_argument(
+        "--port", type=int, required=True, help="Local port to expose"
+    )
+    parser.add_argument(
+        "--host", type=str, default="localhost", help="Local host (default: localhost)"
+    )
+    parser.add_argument(
+        "--protocol",
+        type=str,
+        choices=["http", "https"],
+        default="http",
+        help="Protocol (default: http)",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {_installed_version()}",
+    )
+
+    args = parser.parse_args()
+
+    if not 1 <= args.port <= 65535:
+        parser.error("--port must be between 1 and 65535")
+
+    tunnel = Tunnel(port=args.port, host=args.host, protocol=args.protocol)
+
+    shutdown = False
+
+    def _handle_signal(signum, frame):
+        nonlocal shutdown
+        if shutdown:
+            sys.exit(1)
+        shutdown = True
+        print("\nShutting down tunnel...", file=sys.stderr)
+        tunnel.stop()
+
+    signal.signal(signal.SIGINT, _handle_signal)
+    signal.signal(signal.SIGTERM, _handle_signal)
+
+    try:
+        _print_panel()
+        if not _local_server_exists(args.host, args.port):
+            print(
+                _color(
+                    f"No localhost server or app was found on {args.host}:{args.port}.",
+                    _RED,
+                    _BOLD,
+                ),
+                file=sys.stderr,
+            )
+            return 1
+
+        print(
+            _color(
+                f"Starting tunnel for {args.protocol}://{args.host}:{args.port}...",
+                _YELLOW,
+            ),
+            file=sys.stderr,
+        )
+        url = tunnel.start()
+
+        print(_color("\nTunnel is live under:", _GREEN), file=sys.stderr)
+        print(url)
+        sys.stdout.flush()
+        print(_color("Press Ctrl+C to stop.", _DIM), file=sys.stderr)
+
+        # Block until tunnel exits or user interrupts
+        import time
+
+        while tunnel.is_running and not shutdown:
+            time.sleep(1)
+
+        if not shutdown and not tunnel.is_running:
+            print("Tunnel process exited unexpectedly.", file=sys.stderr)
+            return 1
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    finally:
+        tunnel.stop()
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

atunnel-1.0.0/src/atunnel/tunnel.py

@@ -0,0 +1,109 @@
+"""
+Starts a cloudflared quick tunnel subprocess and parses the public URL.
+"""
+
+import re
+import subprocess
+import threading
+import time
+from pathlib import Path
+from typing import Optional
+
+from atunnel.binary import ensure_binary
+
+
+_URL_PATTERN = re.compile(
+    r"https://[-a-zA-Z0-9@:%._\+~#=]{1,256}\.trycloudflare\.com"
+)
+
+
+class Tunnel:
+    """Manages a cloudflared quick tunnel subprocess."""
+
+    def __init__(self, port: int, host: str = "localhost", protocol: str = "http") -> None:
+        self.port = port
+        self.host = host
+        self.protocol = protocol
+        self._process: Optional[subprocess.Popen] = None
+        self._public_url: Optional[str] = None
+        self._output_lines: list = []
+        self._lock = threading.Lock()
+
+    @property
+    def public_url(self) -> Optional[str]:
+        return self._public_url
+
+    @property
+    def is_running(self) -> bool:
+        return self._process is not None and self._process.poll() is None
+
+    def start(self, timeout: float = 30.0) -> str:
+        """Start the tunnel and return the public URL."""
+        binary = ensure_binary()
+        local_url = f"{self.protocol}://{self.host}:{self.port}"
+        cmd = [str(binary), "tunnel", "--url", local_url, "--no-autoupdate"]
+
+        self._process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1
+        )
+
+        reader = threading.Thread(target=self._read_stderr, daemon=True)
+        reader.start()
+
+        url = self._wait_for_url(timeout)
+        if url is None:
+            self.stop()
+            output = "\n".join(self._output_lines[-20:])
+            raise RuntimeError(
+                f"Failed to get tunnel URL within {timeout}s.\nOutput:\n{output}"
+            )
+
+        self._public_url = url
+        return url
+
+    def stop(self) -> None:
+        """Stop the tunnel process."""
+        if self._process is None:
+            return
+        if self._process.poll() is None:
+            self._process.terminate()
+            try:
+                self._process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                self._process.wait(timeout=3)
+        self._process = None
+        self._public_url = None
+
+    def _read_stderr(self) -> None:
+        proc = self._process
+        if proc is None or proc.stderr is None:
+            return
+        try:
+            for line in proc.stderr:
+                line = line.strip()
+                if line:
+                    with self._lock:
+                        self._output_lines.append(line)
+        except (ValueError, OSError):
+            pass
+
+    def _wait_for_url(self, timeout: float) -> Optional[str]:
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if self._process and self._process.poll() is not None:
+                return None
+            with self._lock:
+                for line in self._output_lines:
+                    match = _URL_PATTERN.search(line)
+                    if match:
+                        return match.group(0)
+            time.sleep(0.2)
+        return None
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, *_):
+        self.stop()

atunnel-1.0.0/src/atunnel.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: atunnel
+Version: 1.0.0
+Summary: A-tunnel is a tool to expose localhost to the public internet using Cloudflare Quick Tunnels
+Author-email: Abodx9 <abodx@gmx.de>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Abodx9/A-tunnel
+Keywords: cloudflare,tunnel,localhost,expose,public
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# A-tunnel
+A minimal Python package to expose localhost to the public internet using [Cloudflare Quick Tunnels](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/).
+
+No Cloudflare account required  generates a temporary `*.trycloudflare.com` URL.
+
+## Installation
+
+```bash
+# Using pip
+pip install atunnel
+
+# Or using uv
+uv add atunnel
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Expose local port 8080
+atunnel --port 8080
+
+# With uv
+uv run atunnel --port 8080
+```
+
+The public URL is printed to stdout. Press Ctrl+C to stop.
+
+### Python API
+
+```python
+from atunnel.tunnel import Tunnel
+
+with Tunnel(port=8080) as t:
+    print(f"Public URL: {t.public_url}")
+    input("Press Enter to stop...")

atunnel-1.0.0/src/atunnel.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/atunnel/__init__.py
+src/atunnel/__main__.py
+src/atunnel/binary.py
+src/atunnel/cli.py
+src/atunnel/tunnel.py
+src/atunnel.egg-info/PKG-INFO
+src/atunnel.egg-info/SOURCES.txt
+src/atunnel.egg-info/dependency_links.txt
+src/atunnel.egg-info/entry_points.txt
+src/atunnel.egg-info/top_level.txt

atunnel-1.0.0/src/atunnel.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

atunnel-1.0.0/src/atunnel.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+atunnel = atunnel.cli:main

atunnel-1.0.0/src/atunnel.egg-info/top_level.txt

@@ -0,0 +1 @@
+atunnel