proxy-tuner 0.1.0__tar.gz

proxy_tuner-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: proxy-tuner
+Version: 0.1.0
+Summary: Cross-platform CLI tool for routing traffic through multiple proxy outbounds with flexible rule-based routing by process, domain, IP, and port
+Author-email: HoomanJ <Hooman.Jalalpoor@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/HoomanJ/proxy-tuner
+Project-URL: Documentation, https://github.com/HoomanJ/proxy-tuner/tree/master/docs
+Project-URL: Issues, https://github.com/HoomanJ/proxy-tuner/issues
+Keywords: proxy,tunnel,vpn,routing,socks5,http-proxy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+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: Topic :: System :: Networking
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Provides-Extra: linux
+Requires-Dist: pyroute2>=0.7; extra == "linux"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+
+# ProxyTuner
+
+> **⚠ Warning: This software is in early development (alpha). Do not use in production or sensitive workspaces.**
+> It may contain bugs, insecure defaults, or incomplete security measures.
+> Use only for personal testing and experimentation.
+
+A cross-platform (Windows & Linux) CLI tool for tuning and routing network traffic through multiple proxy outbounds with flexible rule-based routing.
+
+## What It Does
+
+ProxyTuner lets you:
+
+- **Manage proxy outbounds** — add/remove SOCKS5 or HTTP proxies as named outbounds
+- **Define routing rules** — direct traffic to specific outbounds based on:
+  - Process name (e.g., `firefox`, `chrome`, `curl`)
+  - Domain / hostname patterns (regex)
+  - IP addresses and CIDR ranges
+  - URL patterns (regex)
+  - Port ranges
+- **Start/stop tuning** — activate or deactivate traffic redirection at any time
+- **Per-platform optimization** — uses native OS mechanisms:
+  - **Linux**: nftables/iptables TPROXY + TUN interface
+  - **Windows**: WinDivert packet interception
+
+## Quick Start
+
+```bash
+# Install
+pip install proxy-tuner
+
+# Add a SOCKS5 proxy outbound
+proxy-tuner outbound add my-vpn --type socks5 --host 127.0.0.1 --port 1080
+
+# Add an HTTP proxy outbound
+proxy-tuner outbound add my-http --type http --host 127.0.0.1 --port 8080
+
+# Add a routing rule: send Firefox traffic through my-vpn
+proxy-tuner rule add firefox-vpn --process firefox --outbound my-vpn
+
+# Add a rule: send *.cn domains through a specific proxy
+proxy-tuner rule add china-traffic --domain "*.cn" --outbound my-http
+
+# Start tuning
+proxy-tuner start
+
+# Stop tuning
+proxy-tuner stop
+
+# Show status
+proxy-tuner status
+```
+
+## How It Works
+
+ProxyTuner creates a local transparent proxy that intercepts traffic based on your rules and forwards it through the configured outbound proxies.
+
+```
+Application traffic
+        │
+        ▼
+┌──────────────────┐
+│   ProxyTuner     │
+│  (rule engine)   │
+└──────────────────┘
+        │
+   ┌────┴────┐
+   ▼         ▼
+Outbound1  Outbound2
+(SOCKS5)    (HTTP)
+```
+
+On Linux, traffic is redirected to ProxyTuner via nftables/iptables with per-process (`--uid-owner`) matching. On Windows, WinDivert captures packets from specific processes.
+
+## Requirements
+
+- Python 3.10+
+- Linux: `nftables` or `iptables` (root/sudo required)
+- Windows: [WinDivert](https://reqrypt.org/windivert.html) driver (admin required)
+
+## Documentation
+
+- [Architecture](docs/architecture.md) — technical design and internals
+- [Configuration](docs/configuration.md) — config file reference
+- [Usage Guide](docs/usage.md) — CLI commands and examples
+
+## License
+
+MIT

proxy_tuner-0.1.0/README.md

@@ -0,0 +1,88 @@
+# ProxyTuner
+
+> **⚠ Warning: This software is in early development (alpha). Do not use in production or sensitive workspaces.**
+> It may contain bugs, insecure defaults, or incomplete security measures.
+> Use only for personal testing and experimentation.
+
+A cross-platform (Windows & Linux) CLI tool for tuning and routing network traffic through multiple proxy outbounds with flexible rule-based routing.
+
+## What It Does
+
+ProxyTuner lets you:
+
+- **Manage proxy outbounds** — add/remove SOCKS5 or HTTP proxies as named outbounds
+- **Define routing rules** — direct traffic to specific outbounds based on:
+  - Process name (e.g., `firefox`, `chrome`, `curl`)
+  - Domain / hostname patterns (regex)
+  - IP addresses and CIDR ranges
+  - URL patterns (regex)
+  - Port ranges
+- **Start/stop tuning** — activate or deactivate traffic redirection at any time
+- **Per-platform optimization** — uses native OS mechanisms:
+  - **Linux**: nftables/iptables TPROXY + TUN interface
+  - **Windows**: WinDivert packet interception
+
+## Quick Start
+
+```bash
+# Install
+pip install proxy-tuner
+
+# Add a SOCKS5 proxy outbound
+proxy-tuner outbound add my-vpn --type socks5 --host 127.0.0.1 --port 1080
+
+# Add an HTTP proxy outbound
+proxy-tuner outbound add my-http --type http --host 127.0.0.1 --port 8080
+
+# Add a routing rule: send Firefox traffic through my-vpn
+proxy-tuner rule add firefox-vpn --process firefox --outbound my-vpn
+
+# Add a rule: send *.cn domains through a specific proxy
+proxy-tuner rule add china-traffic --domain "*.cn" --outbound my-http
+
+# Start tuning
+proxy-tuner start
+
+# Stop tuning
+proxy-tuner stop
+
+# Show status
+proxy-tuner status
+```
+
+## How It Works
+
+ProxyTuner creates a local transparent proxy that intercepts traffic based on your rules and forwards it through the configured outbound proxies.
+
+```
+Application traffic
+        │
+        ▼
+┌──────────────────┐
+│   ProxyTuner     │
+│  (rule engine)   │
+└──────────────────┘
+        │
+   ┌────┴────┐
+   ▼         ▼
+Outbound1  Outbound2
+(SOCKS5)    (HTTP)
+```
+
+On Linux, traffic is redirected to ProxyTuner via nftables/iptables with per-process (`--uid-owner`) matching. On Windows, WinDivert captures packets from specific processes.
+
+## Requirements
+
+- Python 3.10+
+- Linux: `nftables` or `iptables` (root/sudo required)
+- Windows: [WinDivert](https://reqrypt.org/windivert.html) driver (admin required)
+
+## Documentation
+
+- [Architecture](docs/architecture.md) — technical design and internals
+- [Configuration](docs/configuration.md) — config file reference
+- [Usage Guide](docs/usage.md) — CLI commands and examples
+
+## License
+
+MIT

proxy_tuner-0.1.0/pyproject.toml

@@ -0,0 +1,72 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "proxy-tuner"
+version = "0.1.0"
+description = "Cross-platform CLI tool for routing traffic through multiple proxy outbounds with flexible rule-based routing by process, domain, IP, and port"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "HoomanJ", email = "Hooman.Jalalpoor@gmail.com" },
+]
+keywords = ["proxy", "tunnel", "vpn", "routing", "socks5", "http-proxy"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: System Administrators",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Networking",
+    "Topic :: System :: Monitoring",
+]
+dependencies = [
+    "click>=8.0",
+    "rich>=13.0",
+]
+
+[project.optional-dependencies]
+linux = [
+    "pyroute2>=0.7",
+]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+    "ruff>=0.1.0",
+    "mypy>=1.0",
+]
+
+[project.scripts]
+proxy-tuner = "proxy_tuner.cli:main"
+
+[project.urls]
+Repository = "https://github.com/HoomanJ/proxy-tuner"
+Documentation = "https://github.com/HoomanJ/proxy-tuner/tree/master/docs"
+Issues = "https://github.com/HoomanJ/proxy-tuner/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "SIM"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

proxy_tuner-0.1.0/setup.cfg

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

proxy_tuner-0.1.0/src/proxy_tuner/__init__.py

@@ -0,0 +1,3 @@
+"""ProxyTuner — cross-platform proxy routing CLI."""
+
+__version__ = "0.1.0"

proxy_tuner-0.1.0/src/proxy_tuner/cli.py

@@ -0,0 +1,109 @@
+"""Main CLI entry point."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from proxy_tuner import __version__
+from proxy_tuner.config import ConfigManager
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="proxy-tuner")
+@click.option(
+    "--config",
+    "config_path",
+    type=click.Path(path_type=Path),
+    default=None,
+    help="Path to config file (default: platform default)",
+)
+@click.pass_context
+def main(ctx: click.Context, config_path: Path | None) -> None:
+    """ProxyTuner — cross-platform proxy routing CLI.
+
+    Route network traffic through multiple proxy outbounds with
+    flexible rule-based routing.
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["config_manager"] = ConfigManager(config_path)
+
+
+# Register subcommands
+from proxy_tuner.cli_config import config_group  # noqa: E402
+from proxy_tuner.cli_logs import logs  # noqa: E402
+from proxy_tuner.cli_monitor import monitor  # noqa: E402
+from proxy_tuner.cli_outbound import outbound_group  # noqa: E402
+from proxy_tuner.cli_rule import rule_group  # noqa: E402
+from proxy_tuner.cli_start import start, status, stop  # noqa: E402
+from proxy_tuner.cli_stats import stats  # noqa: E402
+from proxy_tuner.completions import completions_group  # noqa: E402
+from proxy_tuner.doctor import doctor  # noqa: E402
+from proxy_tuner.setup_wizard import setup_wizard  # noqa: E402
+
+main.add_command(outbound_group)
+main.add_command(rule_group)
+main.add_command(config_group)
+main.add_command(completions_group)
+main.add_command(setup_wizard)
+main.add_command(doctor)
+main.add_command(logs)
+main.add_command(stats)
+main.add_command(monitor)
+main.add_command(start)
+main.add_command(stop)
+main.add_command(status)
+
+
+@main.command("version")
+def version_cmd() -> None:
+    """Show version information."""
+    from rich.console import Console
+
+    Console().print(f"proxy-tuner {__version__}")
+
+
+@main.command("reload")
+@click.pass_context
+def reload(ctx: click.Context) -> None:
+    """Reload configuration (hot-reload while running)."""
+    import os
+    import signal
+
+    manager: ConfigManager = ctx.obj["config_manager"]
+
+    from proxy_tuner.cli_start import _read_pid
+
+    pid = _read_pid(manager)
+    if pid is None:
+        console.print("[yellow]ProxyTuner is not running.[/yellow]")
+        raise click.Abort()
+
+    # Validate new config
+    try:
+        config = manager.load()
+    except Exception as e:
+        console.print(f"[red]Config error:[/red] {e}")
+        raise click.Abort() from e
+
+    errors = config.validate_references()
+    if errors:
+        console.print("[red]Config validation errors:[/red]")
+        for err in errors:
+            console.print(f"  • {err}")
+        raise click.Abort()
+
+    # Send SIGHUP to trigger reload
+    try:
+        os.kill(pid, signal.SIGHUP)
+        console.print(f"[green]✓[/green] Sent reload signal to PID {pid}")
+    except OSError as e:
+        console.print(f"[red]Error:[/red] {e}")
+
+
+if __name__ == "__main__":
+    main()

proxy_tuner-0.1.0/src/proxy_tuner/cli_config.py

@@ -0,0 +1,152 @@
+"""Config management CLI subcommands."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+from rich.syntax import Syntax
+
+from proxy_tuner.config import ConfigManager
+
+console = Console()
+
+
+@click.group("config")
+def config_group() -> None:
+    """Manage configuration."""
+
+
+@config_group.command("show")
+@click.pass_context
+def show_config(ctx: click.Context) -> None:
+    """Display the current configuration."""
+    import json
+
+    manager: ConfigManager = ctx.obj["config_manager"]
+    config = manager.get()
+
+    from proxy_tuner.config import _serialize_config
+
+    output = json.dumps(_serialize_config(config), indent=2, ensure_ascii=False)
+    console.print(Syntax(output, "json", theme="monokai"))
+
+
+@config_group.command("path")
+@click.pass_context
+def config_path(ctx: click.Context) -> None:
+    """Show the config file path."""
+    manager: ConfigManager = ctx.obj["config_manager"]
+    console.print(str(manager.path))
+
+
+@config_group.command("edit")
+@click.pass_context
+def edit_config(ctx: click.Context) -> None:
+    """Open the config file in the default editor."""
+    import os
+    import subprocess
+
+    manager: ConfigManager = ctx.obj["config_manager"]
+
+    # Ensure file exists
+    if not manager.path.exists():
+        manager.save(manager.get())
+
+    editor = os.environ.get("EDITOR", "vi")
+    try:
+        subprocess.run([editor, str(manager.path)], check=True)
+        console.print(f"[green]✓[/green] Config edited at {manager.path}")
+    except FileNotFoundError:
+        msg = f"[red]Error:[/red] Editor '{editor}' not found."
+        console.print(msg + " Set $EDITOR or use 'config show'.")
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Error:[/red] Editor exited with code {e.returncode}")
+
+
+@config_group.command("validate")
+@click.pass_context
+def validate_config(ctx: click.Context) -> None:
+    """Validate the configuration file."""
+    manager: ConfigManager = ctx.obj["config_manager"]
+
+    try:
+        config = manager.load()
+    except Exception as e:
+        console.print(f"[red]Parse error:[/red] {e}")
+        raise click.Abort() from e
+
+    errors = config.validate_references()
+    if errors:
+        console.print("[red]Validation errors:[/red]")
+        for err in errors:
+            console.print(f"  • {err}")
+        raise click.Abort()
+
+    console.print("[green]✓[/green] Configuration is valid")
+
+
+@config_group.command("init")
+@click.pass_context
+def init_config(ctx: click.Context) -> None:
+    """Create a default config file."""
+    from proxy_tuner.config import Config
+
+    manager: ConfigManager = ctx.obj["config_manager"]
+
+    if manager.path.exists():
+        console.print(f"[yellow]Config already exists at {manager.path}[/yellow]")
+        if not click.confirm("Overwrite?"):
+            return
+
+    manager.save(Config())
+    console.print(f"[green]✓[/green] Created default config at {manager.path}")
+
+
+@config_group.command("set")
+@click.argument("key")
+@click.argument("value")
+@click.pass_context
+def set_config(ctx: click.Context, key: str, value: str) -> None:
+    """Set a configuration value.
+
+    Examples:
+        proxy-tuner config set settings.listen_port 9090
+        proxy-tuner config set settings.log_level debug
+        proxy-tuner config set settings.dns_server 1.1.1.1
+    """
+    manager: ConfigManager = ctx.obj["config_manager"]
+    config = manager.get()
+
+    # Parse the key path
+    parts = key.split(".")
+    if len(parts) < 2:
+        msg = "[red]Error:[/red] Key must be in format 'section.field'"
+        console.print(f"{msg} (e.g., settings.listen_port)")
+        raise click.Abort()
+
+    section = parts[0]
+    field_name = parts[1]
+
+    # Type coercion
+    if value.lower() == "true":
+        coerced: object = True
+    elif value.lower() == "false":
+        coerced = False
+    elif value.lower() == "null" or value.lower() == "none":
+        coerced = None
+    else:
+        try:
+            coerced = int(value)
+        except ValueError:
+            try:
+                coerced = float(value)
+            except ValueError:
+                coerced = value
+
+    if section == "settings" and hasattr(config.settings, field_name):
+        setattr(config.settings, field_name, coerced)
+        manager.save(config)
+        console.print(f"[green]✓[/green] Set {key} = {coerced}")
+    else:
+        console.print(f"[red]Error:[/red] Unknown setting '{key}'. Valid sections: settings")
+        raise click.Abort()

proxy_tuner-0.1.0/src/proxy_tuner/cli_logs.py

@@ -0,0 +1,58 @@
+"""Logs viewing CLI command."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+
+console = Console()
+
+
+@click.command("logs")
+@click.option("-n", "--lines", default=50, type=int, help="Number of lines to show")
+@click.option("-f", "--follow", is_flag=True, help="Follow log output (tail -f)")
+@click.pass_context
+def logs(ctx: click.Context, lines: int, follow: bool) -> None:
+    """View ProxyTuner logs."""
+
+    from proxy_tuner.config import get_config_dir
+
+    log_file = get_config_dir() / "proxy-tuner.log"
+
+    if follow:
+        # Tail -f mode
+        if not log_file.exists():
+            console.print(f"[yellow]Log file not found: {log_file}[/yellow]")
+            return
+
+        console.print(f"[dim]Following {log_file} (Ctrl+C to stop)[/dim]")
+        try:
+            with open(log_file) as f:
+                # Seek to end minus some bytes
+                f.seek(0, 2)
+                size = f.tell()
+                f.seek(max(0, size - 4096))
+                f.readline()  # Skip partial line
+
+                while True:
+                    line = f.readline()
+                    if line:
+                        console.print(line.rstrip())
+                    else:
+                        import time
+                        time.sleep(0.1)
+        except KeyboardInterrupt:
+            pass
+    else:
+        # Show last N lines
+        if not log_file.exists():
+            console.print(f"[yellow]No log file found at {log_file}[/yellow]")
+            msg = "[dim]Logs are written when running with "
+            console.print(msg + "--log-file or in daemon mode[/dim]")
+            return
+
+        with open(log_file) as f:
+            all_lines = f.readlines()
+            recent = all_lines[-lines:]
+            for line in recent:
+                console.print(line.rstrip())

proxy_tuner-0.1.0/src/proxy_tuner/cli_monitor.py

@@ -0,0 +1,84 @@
+"""Monitor command — live view of connections and activity."""
+
+from __future__ import annotations
+
+import time
+
+import click
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+
+console = Console()
+
+
+def _format_bytes(n: int) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if abs(n) < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} TB"
+
+
+@click.command("monitor")
+@click.option("--interval", "-i", default=2, type=int, help="Refresh interval in seconds")
+@click.pass_context
+def monitor(ctx: click.Context, interval: int) -> None:
+    """Live monitoring dashboard."""
+    import json
+
+    from proxy_tuner.config import get_config_dir
+
+    stats_file = get_config_dir() / "stats.json"
+    pid_file = get_config_dir() / "proxytuner.pid"
+
+    def _build_table() -> Table:
+        table = Table(title="ProxyTuner Monitor", show_header=True)
+        table.add_column("Metric", style="bold")
+        table.add_column("Value", justify="right")
+
+        # Status
+        running = False
+        if pid_file.exists():
+            try:
+                import os
+                pid = int(pid_file.read_text().strip())
+                os.kill(pid, 0)
+                running = True
+            except (ValueError, OSError):
+                pass
+
+        status = "[green]Running[/green]" if running else "[red]Stopped[/red]"
+        table.add_row("Status", status)
+
+        # Load stats
+        data = {}
+        if stats_file.exists():
+            try:
+                with open(stats_file) as f:
+                    data = json.load(f)
+            except Exception:
+                pass
+
+        # Aggregate stats
+        total_conns = sum(s.get("connections", 0) for s in data.values())
+        total_sent = sum(s.get("bytes_sent", 0) for s in data.values())
+        total_recv = sum(s.get("bytes_received", 0) for s in data.values())
+        total_errors = sum(s.get("errors", 0) for s in data.values())
+
+        table.add_row("Total connections", str(total_conns))
+        table.add_row("Bytes sent", _format_bytes(total_sent))
+        table.add_row("Bytes received", _format_bytes(total_recv))
+        table.add_row("Errors", str(total_errors))
+        table.add_row("Last update", time.strftime("%H:%M:%S"))
+
+        return table
+
+    try:
+        refresh = 1 // max(interval, 1)
+        with Live(_build_table(), refresh_per_second=refresh, console=console) as live:
+            while True:
+                time.sleep(interval)
+                live.update(_build_table())
+    except KeyboardInterrupt:
+        pass