tunnelgo-client 2.20.0__tar.gz

tunnelgo_client-2.20.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: tunnelgo-client
+Version: 2.20.0
+Summary: TunnelGo 内网穿透客户端 — 通过 pip 一键安装，支持 double-fork 守护进程模式
+Author: TunnelGo Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/ctz168/tunnelgo
+Project-URL: Repository, https://github.com/ctz168/tunnelgo
+Project-URL: Issues, https://github.com/ctz168/tunnelgo/issues
+Keywords: tunnel,ngrok,nat-traversal,reverse-proxy,daemon
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# TunnelGo Client (Python)
+
+TunnelGo 内网穿透客户端的 Python 封装包。通过 `pip` 一键安装，自动下载对应平台的 Go 二进制文件，支持 double-fork 守护进程模式。
+
+## 安装
+
+```bash
+pip install tunnelgo-client
+```
+
+安装后会自动下载对应平台（Linux/macOS/Windows，amd64/arm64）的 Go 二进制文件到 `~/.tunnelgo/bin/`。
+
+## 使用
+
+```bash
+# 基本模式
+tunnelgo-client --key YOUR_TOKEN --port 8080
+
+# 子域名模式（推荐）
+tunnelgo-client -k YOUR_TOKEN -p 8080 --subdomain myapp
+
+# 守护进程模式（Python 原生 double-fork，脱离终端）
+tunnelgo-client -k YOUR_TOKEN -p 8080 --daemon
+
+# 停止守护进程
+tunnelgo-client --stop
+
+# 子域名 + TCP 转发
+tunnelgo-client -k YOUR_TOKEN -p 8080 --subdomain myapp --tcp-ports 22,3306
+
+# 禁用 P2P 直连
+tunnelgo-client -k YOUR_TOKEN -p 8080 --no-p2p
+
+# 强制更新客户端二进制
+tunnelgo-client --update
+```
+
+## Double-Fork 守护进程模式
+
+`--daemon` 参数启动 Python 原生的 double-fork 守护进程模式：
+
+1. 第一次 fork → 创建中间子进程
+2. 中间子进程调用 `setsid()` 成为新会话组长
+3. 第二次 fork → 创建孙进程（实际守护进程）
+4. 中间子进程退出
+5. 孙进程被 init (PID 1) 收养，完全脱离终端
+
+守护进程的日志输出到 `/tmp/tunnelgo-client.log`（Windows 为 `%TEMP%\tunnelgo-client.log`）。
+
+## 参数
+
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| `-k, --key` | 认证令牌（必填） | - |
+| `-p, --port` | 本地服务端口 | 8080 |
+| `-s, --server` | 服务器地址 | aicq.online:6639 |
+| `--host` | 本地服务地址 | localhost |
+| `--p2p-port` | P2P 监听端口 | 与 --port 相同 |
+| `--no-p2p` | 禁用 P2P 直连 | false |
+| `--tcp-ports` | TCP 转发端口，逗号分隔 | - |
+| `--tcp-default` | 设为非TLS同端口默认路由 | false |
+| `--http-port` | HTTP 独立端口模式 | false |
+| `--subdomain` | 子域名前缀 | - |
+| `--daemon` | 以守护进程模式运行 (double-fork) | false |
+| `--stop` | 停止守护进程 | false |
+| `--update` | 强制更新客户端二进制 | false |
+
+## License
+
+MIT

tunnelgo_client-2.20.0/README.md

@@ -0,0 +1,70 @@
+# TunnelGo Client (Python)
+
+TunnelGo 内网穿透客户端的 Python 封装包。通过 `pip` 一键安装，自动下载对应平台的 Go 二进制文件，支持 double-fork 守护进程模式。
+
+## 安装
+
+```bash
+pip install tunnelgo-client
+```
+
+安装后会自动下载对应平台（Linux/macOS/Windows，amd64/arm64）的 Go 二进制文件到 `~/.tunnelgo/bin/`。
+
+## 使用
+
+```bash
+# 基本模式
+tunnelgo-client --key YOUR_TOKEN --port 8080
+
+# 子域名模式（推荐）
+tunnelgo-client -k YOUR_TOKEN -p 8080 --subdomain myapp
+
+# 守护进程模式（Python 原生 double-fork，脱离终端）
+tunnelgo-client -k YOUR_TOKEN -p 8080 --daemon
+
+# 停止守护进程
+tunnelgo-client --stop
+
+# 子域名 + TCP 转发
+tunnelgo-client -k YOUR_TOKEN -p 8080 --subdomain myapp --tcp-ports 22,3306
+
+# 禁用 P2P 直连
+tunnelgo-client -k YOUR_TOKEN -p 8080 --no-p2p
+
+# 强制更新客户端二进制
+tunnelgo-client --update
+```
+
+## Double-Fork 守护进程模式
+
+`--daemon` 参数启动 Python 原生的 double-fork 守护进程模式：
+
+1. 第一次 fork → 创建中间子进程
+2. 中间子进程调用 `setsid()` 成为新会话组长
+3. 第二次 fork → 创建孙进程（实际守护进程）
+4. 中间子进程退出
+5. 孙进程被 init (PID 1) 收养，完全脱离终端
+
+守护进程的日志输出到 `/tmp/tunnelgo-client.log`（Windows 为 `%TEMP%\tunnelgo-client.log`）。
+
+## 参数
+
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| `-k, --key` | 认证令牌（必填） | - |
+| `-p, --port` | 本地服务端口 | 8080 |
+| `-s, --server` | 服务器地址 | aicq.online:6639 |
+| `--host` | 本地服务地址 | localhost |
+| `--p2p-port` | P2P 监听端口 | 与 --port 相同 |
+| `--no-p2p` | 禁用 P2P 直连 | false |
+| `--tcp-ports` | TCP 转发端口，逗号分隔 | - |
+| `--tcp-default` | 设为非TLS同端口默认路由 | false |
+| `--http-port` | HTTP 独立端口模式 | false |
+| `--subdomain` | 子域名前缀 | - |
+| `--daemon` | 以守护进程模式运行 (double-fork) | false |
+| `--stop` | 停止守护进程 | false |
+| `--update` | 强制更新客户端二进制 | false |
+
+## License
+
+MIT

tunnelgo_client-2.20.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tunnelgo-client"
+version = "2.20.0"
+description = "TunnelGo 内网穿透客户端 — 通过 pip 一键安装，支持 double-fork 守护进程模式"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [
+    {name = "TunnelGo Contributors"},
+]
+keywords = ["tunnel", "ngrok", "nat-traversal", "reverse-proxy", "daemon"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet :: Proxy Servers",
+    "Topic :: System :: Networking",
+]
+
+[project.scripts]
+tunnelgo-client = "tunnelgo_client.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/ctz168/tunnelgo"
+Repository = "https://github.com/ctz168/tunnelgo"
+Issues = "https://github.com/ctz168/tunnelgo/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

tunnelgo_client-2.20.0/setup.cfg

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

tunnelgo_client-2.20.0/src/tunnelgo_client/__init__.py

@@ -0,0 +1,10 @@
+"""
+TunnelGo Client — 内网穿透客户端 Python 封装
+
+通过 pip 安装后可直接使用 tunnelgo-client 命令。
+自动从 GitHub Releases 下载对应平台的 Go 二进制文件。
+支持 double-fork 守护进程模式（--daemon）。
+"""
+
+__version__ = "2.20.0"
+__author__ = "TunnelGo Contributors"

tunnelgo_client-2.20.0/src/tunnelgo_client/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m tunnelgo_client`."""
+from .cli import main
+
+if __name__ == "__main__":
+    main()

tunnelgo_client-2.20.0/src/tunnelgo_client/cli.py

@@ -0,0 +1,130 @@
+"""
+CLI entry point for the tunnelgo-client Python package.
+
+Provides the same interface as the Go binary, plus automatic
+binary download and Python-native double-fork daemon mode.
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+
+from . import __version__
+from .downloader import ensure_binary
+from .daemon import double_fork_daemon, stop_daemon
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="tunnelgo-client",
+        description=f"TunnelGo 客户端 v{__version__} (Python 封装，自动下载 Go 二进制)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例:
+  tunnelgo-client --key YOUR_TOKEN --port 8080
+  tunnelgo-client -k YOUR_TOKEN -p 3000 -s aicq.online:6639
+  tunnelgo-client -k YOUR_TOKEN -p 80 --no-p2p
+  tunnelgo-client -k TOKEN -p 80 --daemon            后台守护进程运行 (double-fork)
+  tunnelgo-client --stop                               停止守护进程
+
+P2P 模式 (默认启用):
+  优先级: IPv6 直连 > UPnP IPv4 > 服务器中转
+""",
+    )
+
+    parser.add_argument("-k", "--key", default="", help="认证令牌 (必须)")
+    parser.add_argument("-p", "--port", type=int, default=8080, help="本地服务端口 (默认: 8080)")
+    parser.add_argument("-s", "--server", default="aicq.online:6639", help="服务器地址 (默认: aicq.online:6639)")
+    parser.add_argument("--host", default="localhost", help="本地服务地址 (默认: localhost)")
+    parser.add_argument("--p2p-port", type=int, default=0, help="P2P 监听端口 (默认: 与 --port 相同)")
+    parser.add_argument("--no-p2p", action="store_true", help="禁用 P2P 直连，强制使用服务器中转模式")
+    parser.add_argument("--tcp-ports", default="", help="TCP 转发端口，逗号分隔 (如: 22,3306)")
+    parser.add_argument("--http-port", action="store_true", help="启用 HTTP 独立端口模式")
+    parser.add_argument("--subdomain", default="", help="子域名前缀 (如: myapp)")
+    parser.add_argument("--tcp-default", action="store_true", help="设为非TLS同端口默认路由")
+    parser.add_argument("--daemon", action="store_true", help="以守护进程模式运行 (double-fork，脱离终端)")
+    parser.add_argument("--stop", action="store_true", help="停止守护进程 (通过 PID 文件)")
+    parser.add_argument("--update", action="store_true", help="强制更新到最新版本的客户端二进制")
+    parser.add_argument("--version", action="version", version=f"tunnelgo-client v{__version__} (Python)")
+
+    args = parser.parse_args()
+
+    # Handle --stop
+    if args.stop:
+        stop_daemon()
+        return
+
+    # Validate required arguments
+    if not args.key:
+        parser.error("必须提供认证令牌 (--key)")
+
+    # Ensure the Go binary is available
+    try:
+        binary_path = ensure_binary()
+    except RuntimeError as e:
+        print(f"错误: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Handle --update
+    if args.update:
+        from .downloader import download_binary
+        try:
+            binary_path = download_binary(force=True)
+            print(f"  客户端已更新: {binary_path}")
+        except RuntimeError as e:
+            print(f"更新失败: {e}", file=sys.stderr)
+            sys.exit(1)
+        return
+
+    # Build Go binary arguments
+    go_args = []
+    go_args.extend(["-k", args.key])
+    go_args.extend(["-p", str(args.port)])
+    go_args.extend(["-s", args.server])
+    go_args.extend(["--host", args.host])
+
+    if args.p2p_port:
+        go_args.extend(["--p2p-port", str(args.p2p_port)])
+
+    if args.no_p2p:
+        go_args.append("--no-p2p")
+
+    if args.tcp_ports:
+        go_args.extend(["--tcp-ports", args.tcp_ports])
+
+    if args.http_port:
+        go_args.append("--http-port")
+
+    if args.subdomain:
+        go_args.extend(["--subdomain", args.subdomain])
+
+    if args.tcp_default:
+        go_args.append("--tcp-default")
+
+    # Handle --daemon: use Python-native double-fork
+    if args.daemon:
+        # Do NOT pass --daemon to Go binary — Python handles the double-fork
+        # The Go binary will run in the foreground inside the daemon process
+        double_fork_daemon(binary_path, go_args)
+        return
+
+    # Normal mode: run the Go binary in the foreground
+    try:
+        result = subprocess.run(
+            [binary_path] + go_args,
+            stdin=sys.stdin,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+        )
+        sys.exit(result.returncode)
+    except KeyboardInterrupt:
+        sys.exit(0)
+    except FileNotFoundError:
+        print(f"错误: 找不到客户端二进制: {binary_path}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tunnelgo_client-2.20.0/src/tunnelgo_client/daemon.py

@@ -0,0 +1,212 @@
+"""
+Double-fork daemon mode for TunnelGo client.
+
+Implements the classic Unix double-fork pattern in Python:
+  1. First fork → child_1 (intermediate)
+  2. Child_1: setsid() to become session leader
+  3. Second fork → child_2 (grandchild, the actual daemon)
+  4. Child_1 exits
+  5. Grandchild: redirect stdio, write PID file, run the client
+
+This ensures the daemon is fully detached from the terminal
+and cannot accidentally acquire a controlling terminal.
+"""
+
+import os
+import sys
+import signal
+import subprocess
+import time
+
+
+def pid_file_path():
+    """Return the path to the PID file."""
+    return "/tmp/tunnelgo-client.pid"
+
+
+def log_file_path():
+    """Return the path to the daemon log file."""
+    if sys.platform == "win32":
+        return os.path.join(os.environ.get("TEMP", os.environ.get("TMP", "C:\\Temp")), "tunnelgo-client.log")
+    return "/tmp/tunnelgo-client.log"
+
+
+def write_pid_file():
+    """Write the current PID to the PID file."""
+    with open(pid_file_path(), "w") as f:
+        f.write(str(os.getpid()))
+
+
+def remove_pid_file():
+    """Remove the PID file."""
+    try:
+        os.remove(pid_file_path())
+    except FileNotFoundError:
+        pass
+
+
+def stop_daemon():
+    """Stop the daemon process via PID file."""
+    try:
+        with open(pid_file_path(), "r") as f:
+            pid = int(f.read().strip())
+    except (FileNotFoundError, ValueError):
+        print("守护进程未运行 (PID 文件不存在)", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        print(f"进程 {pid} 不存在", file=sys.stderr)
+    except PermissionError:
+        print(f"无权限终止进程 {pid}", file=sys.stderr)
+        sys.exit(1)
+    except OSError as e:
+        print(f"终止进程 {pid} 失败: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    remove_pid_file()
+    print(f"  守护进程已停止 (PID: {pid})")
+
+
+def double_fork_daemon(binary_path, args):
+    """
+    Start the TunnelGo client as a double-fork daemon.
+
+    This implements the classic Unix double-fork pattern:
+      1. Fork → child (intermediate process)
+      2. Child: setsid() to become session leader
+      3. Fork again → grandchild (actual daemon)
+      4. Child exits
+      5. Grandchild: redirect stdio, write PID, exec the Go binary
+
+    On Windows, this falls back to a simple detached subprocess.
+
+    Args:
+        binary_path: Path to the Go client binary.
+        args: List of command-line arguments to pass to the binary.
+    """
+    if sys.platform == "win32":
+        _daemon_windows(binary_path, args)
+        return
+
+    # Unix: true double-fork
+    _daemon_unix(binary_path, args)
+
+
+def _daemon_unix(binary_path, args):
+    """Double-fork daemon implementation for Unix systems."""
+    # Build the full command
+    cmd = [binary_path] + args
+
+    # First fork
+    try:
+        pid = os.fork()
+    except OSError as e:
+        print(f"守护进程错误: 第一次 fork 失败: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if pid > 0:
+        # Parent process: wait briefly for daemon to start, then return
+        # The child will fork again and the grandchild will be the actual daemon
+        os.waitpid(pid, 0)  # Wait for intermediate child to exit
+
+        # Wait for PID file to appear
+        for _ in range(20):
+            try:
+                with open(pid_file_path(), "r") as f:
+                    daemon_pid = int(f.read().strip())
+                if daemon_pid > 0:
+                    print(f"  守护进程已启动 (PID: {daemon_pid})")
+                    break
+            except (FileNotFoundError, ValueError):
+                pass
+            time.sleep(0.1)
+        else:
+            print("  守护进程已启动 (PID 文件尚未写入，请查看日志)")
+
+        print(f"  日志文件: {log_file_path()}")
+        print("  停止命令: tunnelgo-client --stop")
+        return
+
+    # First fork child (intermediate): create new session, then fork again
+    os.setsid()  # Become session leader, detach from controlling terminal
+
+    # Second fork
+    try:
+        pid2 = os.fork()
+    except OSError as e:
+        print(f"守护进程错误: 第二次 fork 失败: {e}", file=sys.stderr)
+        os._exit(1)
+
+    if pid2 > 0:
+        # Intermediate child exits — grandchild is adopted by init (PID 1)
+        os._exit(0)
+
+    # Grandchild: the actual daemon process
+    # Redirect standard file descriptors
+    _redirect_stdio()
+
+    # Write PID file
+    write_pid_file()
+
+    # Execute the Go binary (replaces the Python process)
+    try:
+        os.execv(binary_path, cmd)
+    except OSError as e:
+        print(f"守护进程错误: 无法执行 {binary_path}: {e}", file=sys.stderr)
+        remove_pid_file()
+        os._exit(1)
+
+
+def _daemon_windows(binary_path, args):
+    """Daemon implementation for Windows (detached subprocess)."""
+    cmd = [binary_path] + args
+
+    log_file = log_file_path()
+    try:
+        lf = open(log_file, "a")
+    except IOError:
+        lf = subprocess.DEVNULL
+
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdin=subprocess.DEVNULL,
+            stdout=lf if lf != subprocess.DEVNULL else subprocess.DEVNULL,
+            stderr=subprocess.STDOUT if lf != subprocess.DEVNULL else subprocess.DEVNULL,
+            creationflags=subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS,
+            close_fds=True,
+        )
+        print(f"  守护进程已启动 (PID: {proc.pid})")
+        print(f"  日志文件: {log_file}")
+        print("  停止命令: tunnelgo-client --stop")
+    except Exception as e:
+        print(f"守护进程错误: 启动失败: {e}", file=sys.stderr)
+        sys.exit(1)
+    finally:
+        if lf != subprocess.DEVNULL:
+            lf.close()
+
+
+def _redirect_stdio():
+    """Redirect stdin/stdout/stderr for the daemon process."""
+    # stdin → /dev/null
+    devnull = os.open(os.devnull, os.O_RDWR)
+    os.dup2(devnull, 0)  # stdin
+
+    # stdout/stderr → log file
+    log_path = log_file_path()
+    try:
+        log_fd = os.open(log_path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o644)
+    except OSError:
+        log_fd = devnull
+
+    os.dup2(log_fd, 1)  # stdout
+    os.dup2(log_fd, 2)  # stderr
+
+    # Close original fds
+    if devnull > 2:
+        os.close(devnull)
+    if log_fd > 2 and log_fd != devnull:
+        os.close(log_fd)

tunnelgo_client-2.20.0/src/tunnelgo_client/downloader.py

@@ -0,0 +1,177 @@
+"""
+Binary downloader for TunnelGo client.
+
+Downloads the platform-appropriate Go binary from GitHub Releases
+and caches it in ~/.tunnelgo/bin/.
+"""
+
+import hashlib
+import io
+import json
+import os
+import platform
+import stat
+import sys
+import urllib.request
+import urllib.error
+import zipfile
+import tarfile
+
+# GitHub repo info
+GITHUB_OWNER = "ctz168"
+GITHUB_REPO = "tunnelgo"
+
+# Cache directory
+CACHE_DIR = os.path.expanduser("~/.tunnelgo/bin")
+VERSION_FILE = os.path.join(CACHE_DIR, ".installed_version")
+
+# Platform mapping: (system, machine) → binary name suffix
+PLATFORM_MAP = {
+    ("Linux", "x86_64"): "tunnelgo-client-linux-amd64",
+    ("Linux", "aarch64"): "tunnelgo-client-linux-arm64",
+    ("Linux", "armv7l"): "tunnelgo-client-linux-arm64",
+    ("Darwin", "x86_64"): "tunnelgo-client-darwin-amd64",
+    ("Darwin", "arm64"): "tunnelgo-client-darwin-arm64",
+    ("Windows", "AMD64"): "tunnelgo-client-windows-amd64.exe",
+}
+
+
+def get_platform_binary_name():
+    """Return the binary filename for the current platform."""
+    system = platform.system()
+    machine = platform.machine()
+
+    # Normalize machine names
+    machine_lower = machine.lower()
+    if machine_lower in ("x86_64", "amd64"):
+        machine_key = "x86_64" if system != "Windows" else "AMD64"
+    elif machine_lower in ("aarch64", "arm64", "armv7l"):
+        machine_key = machine
+    else:
+        machine_key = machine
+
+    key = (system, machine_key)
+    if key in PLATFORM_MAP:
+        return PLATFORM_MAP[key]
+
+    # Fallback: try common combinations
+    for k, v in PLATFORM_MAP.items():
+        if k[0] == system:
+            return v
+
+    raise RuntimeError(
+        f"Unsupported platform: {system} {machine}. "
+        f"Please download the binary manually from "
+        f"https://github.com/{GITHUB_OWNER}/{GITHUB_REPO}/releases"
+    )
+
+
+def get_latest_version():
+    """Fetch the latest release version from GitHub API."""
+    api_url = f"https://api.github.com/repos/{GITHUB_OWNER}/{GITHUB_REPO}/releases/latest"
+    try:
+        req = urllib.request.Request(api_url, headers={"User-Agent": "tunnelgo-client-python"})
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode())
+            return data.get("tag_name", "").lstrip("v")
+    except Exception:
+        return None
+
+
+def get_installed_version():
+    """Read the currently installed version from the version file."""
+    try:
+        with open(VERSION_FILE, "r") as f:
+            return f.read().strip()
+    except (FileNotFoundError, IOError):
+        return None
+
+
+def get_binary_path():
+    """Return the full path to the cached binary."""
+    binary_name = get_platform_binary_name()
+    # Normalize: strip .exe for the local copy on non-Windows
+    if platform.system() != "Windows" and binary_name.endswith(".exe"):
+        binary_name = binary_name[:-4]
+    return os.path.join(CACHE_DIR, binary_name)
+
+
+def download_binary(version=None, force=False):
+    """
+    Download the TunnelGo client binary from GitHub Releases.
+
+    Args:
+        version: Specific version to download (e.g. "2.20.0"). If None, uses latest.
+        force: Force re-download even if binary exists.
+
+    Returns:
+        Path to the downloaded binary.
+    """
+    binary_path = get_binary_path()
+
+    # Check if binary already exists and is up-to-date
+    if not force and os.path.isfile(binary_path) and os.access(binary_path, os.X_OK):
+        installed = get_installed_version()
+        if installed and (version is None or installed == version):
+            return binary_path
+
+    # Determine version
+    if version is None:
+        version = get_latest_version()
+    if version is None:
+        version = "latest"
+
+    # Build download URL
+    binary_name = get_platform_binary_name()
+    if version == "latest":
+        download_url = (
+            f"https://github.com/{GITHUB_OWNER}/{GITHUB_REPO}/releases/latest/download/{binary_name}"
+        )
+    else:
+        download_url = (
+            f"https://github.com/{GITHUB_OWNER}/{GITHUB_REPO}/releases/download/v{version}/{binary_name}"
+        )
+
+    # Create cache directory
+    os.makedirs(CACHE_DIR, exist_ok=True)
+
+    # Download
+    print(f"  正在下载 TunnelGo 客户端 v{version} ({binary_name})...")
+    try:
+        req = urllib.request.Request(download_url, headers={"User-Agent": "tunnelgo-client-python"})
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            data = resp.read()
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(
+            f"下载失败 (HTTP {e.code}): {download_url}\n"
+            f"请手动从 https://github.com/{GITHUB_OWNER}/{GITHUB_REPO}/releases 下载"
+        )
+    except Exception as e:
+        raise RuntimeError(f"下载失败: {e}")
+
+    # Write binary
+    with open(binary_path, "wb") as f:
+        f.write(data)
+
+    # Make executable
+    os.chmod(binary_path, os.stat(binary_path).st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+    # Write version file
+    if version != "latest":
+        with open(VERSION_FILE, "w") as f:
+            f.write(version)
+
+    size_mb = len(data) / (1024 * 1024)
+    print(f"  下载完成 ({size_mb:.1f} MB) → {binary_path}")
+
+    return binary_path
+
+
+def ensure_binary(version=None):
+    """
+    Ensure the binary is available, downloading if necessary.
+
+    Returns:
+        Path to the binary.
+    """
+    return download_binary(version=version, force=False)

tunnelgo_client-2.20.0/src/tunnelgo_client.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: tunnelgo-client
+Version: 2.20.0
+Summary: TunnelGo 内网穿透客户端 — 通过 pip 一键安装，支持 double-fork 守护进程模式
+Author: TunnelGo Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/ctz168/tunnelgo
+Project-URL: Repository, https://github.com/ctz168/tunnelgo
+Project-URL: Issues, https://github.com/ctz168/tunnelgo/issues
+Keywords: tunnel,ngrok,nat-traversal,reverse-proxy,daemon
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# TunnelGo Client (Python)
+
+TunnelGo 内网穿透客户端的 Python 封装包。通过 `pip` 一键安装，自动下载对应平台的 Go 二进制文件，支持 double-fork 守护进程模式。
+
+## 安装
+
+```bash
+pip install tunnelgo-client
+```
+
+安装后会自动下载对应平台（Linux/macOS/Windows，amd64/arm64）的 Go 二进制文件到 `~/.tunnelgo/bin/`。
+
+## 使用
+
+```bash
+# 基本模式
+tunnelgo-client --key YOUR_TOKEN --port 8080
+
+# 子域名模式（推荐）
+tunnelgo-client -k YOUR_TOKEN -p 8080 --subdomain myapp
+
+# 守护进程模式（Python 原生 double-fork，脱离终端）
+tunnelgo-client -k YOUR_TOKEN -p 8080 --daemon
+
+# 停止守护进程
+tunnelgo-client --stop
+
+# 子域名 + TCP 转发
+tunnelgo-client -k YOUR_TOKEN -p 8080 --subdomain myapp --tcp-ports 22,3306
+
+# 禁用 P2P 直连
+tunnelgo-client -k YOUR_TOKEN -p 8080 --no-p2p
+
+# 强制更新客户端二进制
+tunnelgo-client --update
+```
+
+## Double-Fork 守护进程模式
+
+`--daemon` 参数启动 Python 原生的 double-fork 守护进程模式：
+
+1. 第一次 fork → 创建中间子进程
+2. 中间子进程调用 `setsid()` 成为新会话组长
+3. 第二次 fork → 创建孙进程（实际守护进程）
+4. 中间子进程退出
+5. 孙进程被 init (PID 1) 收养，完全脱离终端
+
+守护进程的日志输出到 `/tmp/tunnelgo-client.log`（Windows 为 `%TEMP%\tunnelgo-client.log`）。
+
+## 参数
+
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| `-k, --key` | 认证令牌（必填） | - |
+| `-p, --port` | 本地服务端口 | 8080 |
+| `-s, --server` | 服务器地址 | aicq.online:6639 |
+| `--host` | 本地服务地址 | localhost |
+| `--p2p-port` | P2P 监听端口 | 与 --port 相同 |
+| `--no-p2p` | 禁用 P2P 直连 | false |
+| `--tcp-ports` | TCP 转发端口，逗号分隔 | - |
+| `--tcp-default` | 设为非TLS同端口默认路由 | false |
+| `--http-port` | HTTP 独立端口模式 | false |
+| `--subdomain` | 子域名前缀 | - |
+| `--daemon` | 以守护进程模式运行 (double-fork) | false |
+| `--stop` | 停止守护进程 | false |
+| `--update` | 强制更新客户端二进制 | false |
+
+## License
+
+MIT

tunnelgo_client-2.20.0/src/tunnelgo_client.egg-info/SOURCES.txt

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

tunnelgo_client-2.20.0/src/tunnelgo_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tunnelgo_client-2.20.0/src/tunnelgo_client.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tunnelgo-client = tunnelgo_client.cli:main

tunnelgo_client-2.20.0/src/tunnelgo_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+tunnelgo_client