linksocks 3.0.12__tar.gz

linksocks-3.0.12/MANIFEST.in

@@ -0,0 +1,18 @@
+# Include Go source files in linksocks_go directory
+recursive-include linksocks_go *.go
+include go.mod
+include go.sum
+
+# Include documentation
+include README.md
+
+# Exclude unnecessary files
+global-exclude __pycache__
+global-exclude *.py[co]
+global-exclude .git*
+global-exclude *.so
+global-exclude *.dylib
+global-exclude *.dll
+
+# Exclude existing bindings directory to force rebuild
+prune linksockslib

linksocks-3.0.12/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: linksocks
+Version: 3.0.12
+Summary: Python bindings for LinkSocks - SOCKS proxy over WebSocket
+Home-page: https://github.com/linksocks/linksocks
+Author: jackzzs
+Author-email: jackzzs@outlook.com
+License: MIT
+Project-URL: Bug Reports, https://github.com/linksocks/linksocks/issues
+Project-URL: Source, https://github.com/linksocks/linksocks
+Project-URL: Documentation, https://github.com/linksocks/linksocks#readme
+Project-URL: Changelog, https://github.com/linksocks/linksocks/releases
+Keywords: socks proxy websocket network tunneling firewall bypass load-balancing go bindings
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+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: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Go
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: setuptools>=40.0
+Requires-Dist: click>=8.0
+Requires-Dist: loguru
+Requires-Dist: rich
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.10; extra == "dev"
+Requires-Dist: pytest-mock>=3.0; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.8; extra == "dev"
+Requires-Dist: mypy>=0.800; extra == "dev"
+Requires-Dist: httpx[socks]; extra == "dev"
+Requires-Dist: requests; extra == "dev"
+Requires-Dist: pysocks; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: platform
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Python bindings for LinkSocks - a SOCKS proxy implementation over WebSocket protocol.

linksocks-3.0.12/go.mod

@@ -0,0 +1,24 @@
+module github.com/linksocks/linksocks
+
+go 1.21
+
+require (
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.3
+	github.com/rs/zerolog v1.33.0
+	github.com/spf13/cobra v1.8.1
+	github.com/stretchr/testify v1.10.0
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

linksocks-3.0.12/go.sum

@@ -0,0 +1,47 @@
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
+github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
+github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

linksocks-3.0.12/linksocks/__init__.py

@@ -0,0 +1,9 @@
+"""linksocks: SOCKS5 over WebSocket proxy library."""
+
+__version__ = "3.0.12"
+
+from ._server import Server
+from ._client import Client
+from ._base import ReverseTokenResult, set_log_level
+
+__all__ = ["Server", "Client", "ReverseTokenResult", "set_log_level"]

linksocks-3.0.12/linksocks/_base.py

@@ -0,0 +1,230 @@
+"""
+Base classes and utilities for linksocks.
+
+This module contains shared functionality used by Server and Client classes.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import asyncio
+from dataclasses import dataclass
+import threading
+import time
+from datetime import timedelta
+from typing import Any, Callable, Dict, Iterable, Optional, Tuple, Union, List
+
+# Underlying Go bindings module (generated)
+from linksockslib import linksocks # type: ignore
+
+_logger = logging.getLogger(__name__)
+
+# Type aliases
+DurationLike = Union[int, float, timedelta, str]
+
+
+def _snake_to_camel(name: str) -> str:
+    """Convert snake_case to CamelCase."""
+    parts = name.split("_")
+    return "".join(p.capitalize() for p in parts if p)
+
+
+def _camel_to_snake(name: str) -> str:
+    """Convert CamelCase to snake_case."""
+    out: List[str] = []
+    for ch in name:
+        if ch.isupper() and out:
+            out.append("_")
+        out.append(ch.lower())
+    return "".join(out)
+
+
+def _to_duration(value: Optional[DurationLike]) -> Any:
+    """Convert seconds/str/timedelta to Go time.Duration via bindings.
+    
+    - None -> 0
+    - int/float -> seconds (supports fractions)
+    - timedelta -> total seconds
+    - str -> parsed by Go (e.g., "1.5s", "300ms")
+    """
+    if value is None:
+        return 0
+    if isinstance(value, timedelta):
+        seconds = value.total_seconds()
+        return seconds * linksocks.Second()
+    if isinstance(value, (int, float)):
+        return value * linksocks.Second()
+    if isinstance(value, str):
+        try:
+            return linksocks.ParseDuration(value)
+        except Exception as exc:
+            raise ValueError(f"Invalid duration string: {value}") from exc
+    raise TypeError(f"Unsupported duration type: {type(value)!r}")
+
+
+# Shared Go->Python log dispatcher
+_def_level_map = {
+    "trace": logging.DEBUG,
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warn": logging.WARNING,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+    "fatal": logging.CRITICAL,
+    "panic": logging.CRITICAL,
+}
+
+
+def _emit_go_log(py_logger: logging.Logger, line: str) -> None:
+    """Process a Go log line and emit it to the Python logger."""
+    try:
+        obj = json.loads(line)
+    except Exception:
+        py_logger.info(line)
+        return
+    level = str(obj.get("level", "")).lower()
+    message = obj.get("message") or obj.get("msg") or ""
+    extras: Dict[str, Any] = {}
+    for k, v in obj.items():
+        if k in ("level", "time", "message", "msg"):
+            continue
+        extras[k] = v
+    py_logger.log(_def_level_map.get(level, logging.INFO), message, extra={"go": extras})
+
+
+# Global registry for logger instances
+_logger_registry: Dict[str, logging.Logger] = {}
+
+# Event-driven log monitoring system
+_log_listeners: List[Callable[[List], None]] = []
+_listener_thread: Optional[threading.Thread] = None
+_listener_active: bool = False
+
+
+def _start_log_listener() -> None:
+    """Start background thread to drain Go log buffer and forward to Python loggers."""
+    global _listener_thread, _listener_active
+    if _listener_active and _listener_thread and _listener_thread.is_alive():
+        return
+    _listener_active = True
+
+    def _run() -> None:
+        # Drain loop: wait for entries with timeout to allow graceful shutdown
+        while _listener_active:
+            try:
+                entries = linksocks.WaitForLogEntries(2000)  # wait up to 2s
+            except Exception:
+                # Backoff on unexpected errors to avoid busy loop
+                time.sleep(0.2)
+                continue
+
+            if not entries:
+                continue
+
+            # Iterate returned entries; handle both attr and dict styles
+            for entry in entries:
+                try:
+                    logger_id = getattr(entry, "LoggerID", None)
+                    if logger_id is None and isinstance(entry, dict):
+                        logger_id = entry.get("LoggerID")
+
+                    message = getattr(entry, "Message", None)
+                    if message is None and isinstance(entry, dict):
+                        message = entry.get("Message")
+
+                    if not message:
+                        continue
+
+                    py_logger = _logger_registry.get(str(logger_id)) or _logger
+                    _emit_go_log(py_logger, str(message))
+                except Exception:
+                    # Never let logging path crash the listener
+                    continue
+
+    _listener_thread = threading.Thread(target=_run, name="linksocks-go-log-listener", daemon=True)
+    _listener_thread.start()
+
+
+def _stop_log_listener() -> None:
+    """Stop the background log listener thread."""
+    global _listener_active
+    _listener_active = False
+    try:
+        # Unblock WaitForLogEntries callers
+        linksocks.CancelLogWaiters()
+    except Exception:
+        pass
+
+
+class BufferZerologLogger:
+    """Buffer-based logger system for Go bindings."""
+    
+    def __init__(self, py_logger: logging.Logger, logger_id: str):
+        self.py_logger = py_logger
+        self.logger_id = logger_id
+        # Ensure background listener is running
+        _start_log_listener()
+
+        # Prefer Go logger with explicit ID so we can map entries back
+        try:
+            # Newer binding that tags entries with our provided ID
+            self.go_logger = linksocks.NewLoggerWithID(self.logger_id)
+        except Exception:
+            # Fallback to older API; if present, still try callback path
+            try:
+                def log_callback(line: str) -> None:
+                    _emit_go_log(py_logger, line)
+
+                self.go_logger = linksocks.NewLogger(log_callback)
+            except Exception:
+                # As a last resort, create a default Go logger
+                self.go_logger = linksocks.NewLoggerWithID(self.logger_id)  # may still raise; surface to caller
+        _logger_registry[logger_id] = py_logger
+    
+    def cleanup(self):
+        """Clean up logger resources."""
+        if self.logger_id in _logger_registry:
+            del _logger_registry[self.logger_id]
+
+
+@dataclass
+class ReverseTokenResult:
+    """Result of adding a reverse token."""
+    token: str
+    port: int
+
+
+class _SnakePassthrough:
+    """Mixin to map snake_case attribute access to underlying CamelCase.
+    
+    Only used when an explicit Pythonic method/attribute is not defined.
+    """
+
+    def __getattr__(self, name: str) -> Any:
+        raw = super().__getattribute__("_raw")  # type: ignore[attr-defined]
+        camel = _snake_to_camel(name)
+        try:
+            return getattr(raw, camel)
+        except AttributeError:
+            raise
+
+    def __dir__(self) -> List[str]:
+        # Expose snake_case versions of underlying CamelCase for IDEs
+        names = set(super().__dir__())
+        try:
+            raw = super().__getattribute__("_raw")  # type: ignore[attr-defined]
+            for attr in dir(raw):
+                if not attr or attr.startswith("_"):
+                    continue
+                names.add(_camel_to_snake(attr))
+        except Exception:
+            pass
+        return sorted(names)
+
+
+def set_log_level(level: Union[int, str]) -> None:
+    """Set the global log level for linksocks."""
+    if isinstance(level, str):
+        level = getattr(logging, level.upper())
+    _logger.setLevel(level)

linksocks-3.0.12/linksocks/_cli.py

@@ -0,0 +1,291 @@
+"""
+Command-line interface for linksocks.
+
+This module provides all CLI commands for the linksocks SOCKS5 over WebSocket proxy tool.
+"""
+
+import asyncio
+import logging
+import platform
+from typing import Optional
+
+import click
+
+from ._logging_config import init_logging
+from ._utils import get_env_or_flag, parse_socks_proxy, validate_required_token
+
+
+@click.group()
+def cli():
+    """SOCKS5 over WebSocket proxy tool."""
+    pass
+
+
+@click.command()
+def version():
+    """Print version and platform information."""
+    try:
+        from linksocks import __version__
+        version_str = __version__
+    except ImportError:
+        version_str = "unknown"
+    
+    platform_str = platform.platform()
+    click.echo(f"linksocks version {version_str} {platform_str}")
+
+
+@click.command()
+@click.option("--token", "-t", help="Authentication token (env: LINKSOCKS_TOKEN)")
+@click.option("--url", "-u", default="ws://localhost:8765", help="WebSocket server address")
+@click.option("--reverse", "-r", is_flag=True, default=False, help="Use reverse SOCKS5 proxy")
+@click.option("--connector-token", "-c", default=None, help="Connector token for reverse proxy (env: LINKSOCKS_CONNECTOR_TOKEN)")
+@click.option("--socks-host", "-s", default="127.0.0.1", help="SOCKS5 server listen address")
+@click.option("--socks-port", "-p", default=9870, help="SOCKS5 server listen port")
+@click.option("--socks-username", "-n", help="SOCKS5 authentication username")
+@click.option("--socks-password", "-w", help="SOCKS5 authentication password (env: LINKSOCKS_SOCKS_PASSWORD)")
+@click.option("--socks-no-wait", "-i", is_flag=True, default=False, help="Start SOCKS server immediately")
+@click.option("--no-reconnect", "-R", is_flag=True, default=False, help="Stop when server disconnects")
+@click.option("--debug", "-d", count=True, help="Debug logging (-d for debug, -dd for trace)")
+@click.option("--threads", "-T", default=1, help="Number of threads for data transfer")
+@click.option("--upstream-proxy", "-x", help="Upstream SOCKS5 proxy (socks5://[user:pass@]host[:port])")
+@click.option("--fast-open", "-f", is_flag=True, default=False, help="Assume connection success and allow data transfer immediately")
+@click.option("--no-env-proxy", "-E", is_flag=True, default=False, help="Ignore proxy env vars for WebSocket connection")
+def client(
+    token: Optional[str],
+    url: str,
+    reverse: bool,
+    connector_token: Optional[str],
+    socks_host: str,
+    socks_port: int,
+    socks_username: Optional[str],
+    socks_password: Optional[str],
+    socks_no_wait: bool,
+    no_reconnect: bool,
+    debug: int,
+    threads: int,
+    upstream_proxy: Optional[str],
+    fast_open: bool,
+    no_env_proxy: bool,
+):
+    """Start SOCKS5 over WebSocket proxy client."""
+    from ._client import Client
+
+    async def main():
+        # Get values from flags or environment
+        actual_token = get_env_or_flag(token, "LINKSOCKS_TOKEN")
+        actual_connector_token = get_env_or_flag(connector_token, "LINKSOCKS_CONNECTOR_TOKEN")
+        actual_socks_password = get_env_or_flag(socks_password, "LINKSOCKS_SOCKS_PASSWORD")
+        
+        # Validate required token
+        try:
+            validated_token = validate_required_token(actual_token)
+        except ValueError as e:
+            raise click.ClickException(str(e)) from e
+        
+        # Setup logging
+        if debug == 0:
+            log_level = logging.INFO
+        elif debug == 1:
+            log_level = logging.DEBUG
+        else:
+            log_level = 5  # TRACE level
+        
+        init_logging(level=log_level)
+
+        # Parse upstream proxy
+        if upstream_proxy:
+            try:
+                upstream_host, upstream_username, upstream_password = parse_socks_proxy(upstream_proxy)
+            except ValueError as e:
+                raise click.ClickException(f"Invalid upstream proxy: {e}") from e
+        else:
+            upstream_host = upstream_username = upstream_password = None
+
+        # Create client
+        client = Client(
+            ws_url=url,
+            token=validated_token,
+            reverse=reverse,
+            socks_host=socks_host,
+            socks_port=socks_port,
+            socks_username=socks_username,
+            socks_password=actual_socks_password,
+            socks_wait_server=not socks_no_wait,
+            reconnect=not no_reconnect,
+            upstream_proxy=upstream_host,
+            upstream_username=upstream_username,
+            upstream_password=upstream_password,
+            threads=threads,
+            fast_open=fast_open,
+            no_env_proxy=no_env_proxy,
+        )
+        
+        # Add connector for reverse mode
+        if actual_connector_token and reverse:
+            await client.async_add_connector(actual_connector_token)
+            await asyncio.sleep(0.2)
+        
+        # Run client
+        async with client:
+            await asyncio.Future()
+
+    asyncio.run(main())
+
+
+@click.command()
+@click.option("--ws-host", "-H", default="0.0.0.0", help="WebSocket server listen address")
+@click.option("--ws-port", "-P", default=8765, help="WebSocket server listen port")
+@click.option("--token", "-t", default=None, help="Auth token, auto-generated if not provided (env: LINKSOCKS_TOKEN)")
+@click.option("--connector-token", "-c", default=None, help="Connector token for reverse proxy (env: LINKSOCKS_CONNECTOR_TOKEN)")
+@click.option("--connector-autonomy", "-a", is_flag=True, default=False, help="Allow clients to manage connector tokens")
+@click.option("--buffer-size", "-b", default=4096, help="Buffer size for data transfer")
+@click.option("--reverse", "-r", is_flag=True, default=False, help="Use reverse SOCKS5 proxy")
+@click.option("--socks-host", "-s", default="127.0.0.1", help="SOCKS5 server listen address for reverse proxy")
+@click.option("--socks-port", "-p", default=9870, help="SOCKS5 server listen port for reverse proxy")
+@click.option("--socks-username", "-n", help="SOCKS5 username for authentication")
+@click.option("--socks-password", "-w", help="SOCKS5 password for authentication (env: LINKSOCKS_SOCKS_PASSWORD)")
+@click.option("--socks-nowait", "-i", is_flag=True, default=False, help="Start SOCKS server immediately")
+@click.option("--debug", "-d", count=True, help="Debug logging (-d for debug, -dd for trace)")
+@click.option("--api-key", "-k", help="Enable HTTP API with specified key")
+@click.option("--upstream-proxy", "-x", help="Upstream SOCKS5 proxy (socks5://[user:pass@]host[:port])")
+@click.option("--fast-open", "-f", is_flag=True, default=False, help="Assume connection success and allow data transfer immediately")
+def server(
+    ws_host: str,
+    ws_port: int,
+    token: Optional[str],
+    connector_token: Optional[str],
+    connector_autonomy: bool,
+    buffer_size: int,
+    reverse: bool,
+    socks_host: str,
+    socks_port: int,
+    socks_username: Optional[str],
+    socks_password: Optional[str],
+    socks_nowait: bool,
+    debug: int,
+    api_key: Optional[str],
+    upstream_proxy: Optional[str],
+    fast_open: bool,
+):
+    """Start SOCKS5 over WebSocket proxy server."""
+    from ._server import Server
+
+    async def main():
+        # Get values from flags or environment
+        actual_token = get_env_or_flag(token, "LINKSOCKS_TOKEN")
+        actual_connector_token = get_env_or_flag(connector_token, "LINKSOCKS_CONNECTOR_TOKEN")
+        actual_socks_password = get_env_or_flag(socks_password, "LINKSOCKS_SOCKS_PASSWORD")
+        
+        # Setup logging
+        if debug == 0:
+            log_level = logging.INFO
+        elif debug == 1:
+            log_level = logging.DEBUG
+        else:
+            log_level = 5  # TRACE level
+        
+        init_logging(level=log_level)
+
+        # Parse upstream proxy
+        if upstream_proxy:
+            try:
+                upstream_host, upstream_username, upstream_password = parse_socks_proxy(upstream_proxy)
+            except ValueError as e:
+                raise click.ClickException(f"Invalid upstream proxy: {e}") from e
+        else:
+            upstream_host = upstream_username = upstream_password = None
+
+        # Create server
+        server = Server(
+            ws_host=ws_host,
+            ws_port=ws_port,
+            socks_host=socks_host,
+            socks_wait_client=not socks_nowait,
+            upstream_proxy=upstream_host,
+            upstream_username=upstream_username,
+            upstream_password=upstream_password,
+            buffer_size=buffer_size,
+            api_key=api_key,
+            fast_open=fast_open,
+        )
+
+        # Configure tokens if no API key
+        if not api_key:
+            if reverse:
+                result = await server.async_add_reverse_token(
+                    token=actual_token,
+                    port=socks_port,
+                    username=socks_username,
+                    password=actual_socks_password,
+                    allow_manage_connector=connector_autonomy,
+                )
+                use_token = result.token
+                
+                if not connector_autonomy:
+                    use_connector_token = await server.async_add_connector_token(
+                        actual_connector_token, use_token
+                    )
+                await asyncio.sleep(0.2)
+
+                server.log.info("Configuration:")
+                server.log.info("  Mode: reverse proxy (SOCKS5 on server -> client -> network)")
+                server.log.info(f"  Token: {use_token}")
+                server.log.info(f"  SOCKS5 port: {result.port}")
+                if socks_username and actual_socks_password:
+                    server.log.info(f"  SOCKS5 username: {socks_username}")
+                if not connector_autonomy:
+                    server.log.info(f"  Connector Token: {use_connector_token}")
+                if connector_autonomy:
+                    server.log.info("  Connector autonomy: enabled")
+            else:
+                use_token = await server.async_add_forward_token(actual_token)
+                await asyncio.sleep(0.2)
+                server.log.info("Configuration:")
+                server.log.info("  Mode: forward proxy (SOCKS5 on client -> server -> network)")
+                server.log.info(f"  Token: {use_token}")
+
+        # Run server
+        async with server:
+            await asyncio.Future()
+
+    asyncio.run(main())
+
+
+def create_provider_command():
+    """Create provider command as alias for client -r."""
+    def provider_wrapper(*args, **kwargs):
+        kwargs['reverse'] = True
+        return client(*args, **kwargs)
+    
+    return click.Command(
+        name="provider",
+        callback=provider_wrapper,
+        params=client.params.copy(),
+        help="Start reverse SOCKS5 proxy client (alias for 'client -r')"
+    )
+
+
+def create_connector_command():
+    """Create connector command as alias for client."""
+    return click.Command(
+        name="connector",
+        callback=client,
+        params=client.params.copy(),
+        help="Start SOCKS5 proxy client (alias for 'client')"
+    )
+
+
+# Create command aliases
+provider_cmd = create_provider_command()
+connector_cmd = create_connector_command()
+
+# Register commands
+cli.add_command(client)
+cli.add_command(connector_cmd)
+cli.add_command(provider_cmd)
+cli.add_command(server)
+cli.add_command(version)
+
+
+if __name__ == "__main__":
+    cli()