proxy-tuner 0.1.0__py3-none-any.whl

proxy_tuner/__init__.py

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

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/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/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/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

proxy_tuner/cli_outbound.py

@@ -0,0 +1,146 @@
+"""Outbound management CLI subcommands."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from proxy_tuner.config import ConfigManager, HttpOutbound, Socks5Outbound
+
+console = Console()
+
+
+@click.group("outbound")
+def outbound_group() -> None:
+    """Manage proxy outbounds."""
+
+
+@outbound_group.command("add")
+@click.argument("name")
+@click.option("--type", "outbound_type", type=click.Choice(["socks5", "http"]), required=True)
+@click.option("--host", required=True, help="Proxy server hostname or IP")
+@click.option("--port", required=True, type=int, help="Proxy server port")
+@click.option("--username", default=None, help="Proxy auth username")
+@click.option("--password", default=None, help="Proxy auth password")
+@click.option("--timeout", default=10, type=int, show_default=True,
+              help="Connection timeout in seconds")
+@click.pass_context
+def add_outbound(
+    ctx: click.Context,
+    name: str,
+    outbound_type: str,
+    host: str,
+    port: int,
+    username: str | None,
+    password: str | None,
+    timeout: int,
+) -> None:
+    """Add a new proxy outbound."""
+    manager: ConfigManager = ctx.obj["config_manager"]
+
+    try:
+        if outbound_type == "socks5":
+            outbound = Socks5Outbound(
+                type="socks5",
+                host=host,
+                port=port,
+                username=username,
+                password=password,
+                timeout=timeout,
+            )
+        else:
+            outbound = HttpOutbound(
+                type="http",
+                host=host,
+                port=port,
+                username=username,
+                password=password,
+                timeout=timeout,
+            )
+
+        manager.add_outbound(name, outbound)
+        console.print(f"[green]✓[/green] Added outbound '[bold]{name}[/bold]' ({outbound_type}://{host}:{port})")
+
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise click.Abort() from e
+
+
+@outbound_group.command("remove")
+@click.argument("name")
+@click.pass_context
+def remove_outbound(ctx: click.Context, name: str) -> None:
+    """Remove an outbound."""
+    manager: ConfigManager = ctx.obj["config_manager"]
+
+    try:
+        manager.remove_outbound(name)
+        console.print(f"[green]✓[/green] Removed outbound '[bold]{name}[/bold]'")
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise click.Abort() from e
+
+
+@outbound_group.command("list")
+@click.pass_context
+def list_outbounds(ctx: click.Context) -> None:
+    """List all configured outbounds."""
+    manager: ConfigManager = ctx.obj["config_manager"]
+    config = manager.get()
+
+    if not config.outbounds:
+        console.print("[dim]No outbounds configured.[/dim]")
+        return
+
+    table = Table(title="Outbounds")
+    table.add_column("Name", style="bold")
+    table.add_column("Type")
+    table.add_column("Host")
+    table.add_column("Port")
+    table.add_column("Timeout")
+
+    for name, ob in config.outbounds.items():
+        if ob.type == "direct":
+            table.add_row(name, "direct", "—", "—", "—")
+        else:
+            table.add_row(
+                name,
+                ob.type,
+                ob.host,
+                str(ob.port),
+                f"{ob.timeout}s",
+            )
+
+    console.print(table)
+
+
+@outbound_group.command("test")
+@click.argument("name")
+@click.pass_context
+def test_outbound(ctx: click.Context, name: str) -> None:
+    """Test connectivity through an outbound proxy."""
+    import asyncio
+
+    from proxy_tuner.outbounds import OutboundManager
+
+    manager: ConfigManager = ctx.obj["config_manager"]
+    config = manager.get()
+
+    if name not in config.outbounds:
+        console.print(f"[red]Error:[/red] Outbound '{name}' does not exist")
+        raise click.Abort()
+
+    ob = config.outbounds[name]
+    target = f"{ob.type}://{ob.host}:{ob.port}" if ob.type != "direct" else "direct"
+    console.print(f"Testing [bold]{name}[/bold] ({target})...")
+
+    ob_manager = OutboundManager(config=config)
+    result = asyncio.run(ob_manager.test_outbound(name))
+
+    if result.success:
+        console.print(f"  Connection: [green]OK[/green] ({result.latency_ms:.0f}ms)")
+        console.print("  Overall: [green]PASS[/green]")
+    else:
+        console.print(f"  Connection: [red]FAIL[/red] — {result.error}")
+        console.print("  Overall: [red]FAIL[/red]")