proxy2vpn 0.1.3__py3-none-any.whl

proxy2vpn/__init__.py

@@ -0,0 +1,20 @@
+"""proxy2vpn Python package."""
+
+try:
+    from importlib.metadata import version
+
+    __version__ = version("proxy2vpn")
+except Exception:
+    # Fallback when package is not installed (development mode)
+    __version__ = "dev"
+
+__all__ = [
+    "cli",
+    "compose_utils",
+    "docker_ops",
+    "compose_manager",
+    "models",
+    "config",
+    "server_manager",
+    "__version__",
+]

proxy2vpn/cli.py

@@ -0,0 +1,416 @@
+"""Command line interface for proxy2vpn."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from .typer_ext import HelpfulTyper
+from docker.errors import APIError, NotFound
+
+from . import config
+from .compose_manager import ComposeManager
+from .models import Profile, VPNService
+from .server_manager import ServerManager
+
+app = HelpfulTyper(help="proxy2vpn command line interface")
+
+profile_app = HelpfulTyper(help="Manage VPN profiles")
+vpn_app = HelpfulTyper(help="Manage VPN services")
+server_app = HelpfulTyper(help="Manage cached server lists")
+bulk_app = HelpfulTyper(help="Bulk container operations")
+preset_app = HelpfulTyper(help="Manage presets")
+
+app.add_typer(profile_app, name="profile")
+app.add_typer(vpn_app, name="vpn")
+app.add_typer(server_app, name="servers")
+app.add_typer(bulk_app, name="bulk")
+app.add_typer(preset_app, name="preset")
+
+
+# ---------------------------------------------------------------------------
+# Profile commands
+# ---------------------------------------------------------------------------
+
+
+@profile_app.command("create")
+def profile_create(name: str, env_file: Path):
+    """Create a new VPN profile."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    profile = Profile(name=name, env_file=str(env_file))
+    manager.add_profile(profile)
+    typer.echo(f"Profile '{name}' created.")
+
+
+@profile_app.command("list")
+def profile_list():
+    """List available profiles."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    for profile in manager.list_profiles():
+        typer.echo(profile.name)
+
+
+@profile_app.command("delete")
+def profile_delete(name: str):
+    """Delete a profile by NAME."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    manager.remove_profile(name)
+    typer.echo(f"Profile '{name}' deleted.")
+
+
+# ---------------------------------------------------------------------------
+# VPN container commands
+# ---------------------------------------------------------------------------
+
+
+@vpn_app.command("create")
+def vpn_create(
+    name: str,
+    profile: str,
+    port: int = typer.Option(0, help="Host port to expose; 0 for auto"),
+    provider: str = typer.Option(config.DEFAULT_PROVIDER),
+    location: str = typer.Option("", help="Optional location, e.g. city"),
+):
+    """Create a VPN service entry in the compose file."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    if port == 0:
+        port = manager.next_available_port(config.DEFAULT_PORT_START)
+    env = {"VPN_SERVICE_PROVIDER": provider}
+    if location:
+        env["SERVER_CITIES"] = location
+    labels = {
+        "vpn.type": "vpn",
+        "vpn.port": str(port),
+        "vpn.provider": provider,
+        "vpn.profile": profile,
+        "vpn.location": location,
+    }
+    svc = VPNService(
+        name=name,
+        port=port,
+        provider=provider,
+        profile=profile,
+        location=location,
+        environment=env,
+        labels=labels,
+    )
+    manager.add_service(svc)
+    typer.echo(f"Service '{name}' created on port {port}.")
+
+
+@vpn_app.command("list")
+def vpn_list():
+    """List VPN services with their status and IP addresses."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    from .docker_ops import get_vpn_containers, get_container_ip
+
+    services = manager.list_services()
+    containers = {c.name: c for c in get_vpn_containers(all=True)}
+
+    typer.echo(f"{'NAME':<15} {'PORT':<8} {'PROFILE':<12} {'STATUS':<10} {'IP':<15}")
+    typer.echo("-" * 65)
+    for svc in services:
+        container = containers.get(svc.name)
+        if container:
+            status = container.status
+            ip = get_container_ip(container) if status == "running" else "N/A"
+        else:
+            status = "not created"
+            ip = "N/A"
+        typer.echo(
+            f"{svc.name:<15} {svc.port:<8} {svc.profile:<12} {status:<10} {ip:<15}"
+        )
+
+
+@vpn_app.command("start")
+def vpn_start(name: str):
+    """Start the container for a VPN service."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    try:
+        manager.get_service(name)
+    except KeyError:
+        typer.echo(f"Service '{name}' not found.", err=True)
+        raise typer.Exit(1)
+
+    from .docker_ops import start_container
+
+    try:
+        start_container(name)
+        typer.echo(f"Started '{name}'.")
+    except NotFound:
+        typer.echo(f"Container '{name}' does not exist.", err=True)
+        raise typer.Exit(1)
+    except APIError as exc:
+        typer.echo(f"Failed to start '{name}': {exc.explanation}", err=True)
+        raise typer.Exit(1)
+
+
+@vpn_app.command("stop")
+def vpn_stop(name: str):
+    """Stop the container for a VPN service."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    try:
+        manager.get_service(name)
+    except KeyError:
+        typer.echo(f"Service '{name}' not found.", err=True)
+        raise typer.Exit(1)
+
+    from .docker_ops import stop_container
+
+    try:
+        stop_container(name)
+        typer.echo(f"Stopped '{name}'.")
+    except NotFound:
+        typer.echo(f"Container '{name}' does not exist.", err=True)
+        raise typer.Exit(1)
+    except APIError as exc:
+        typer.echo(f"Failed to stop '{name}': {exc.explanation}", err=True)
+        raise typer.Exit(1)
+
+
+@vpn_app.command("restart")
+def vpn_restart(name: str):
+    """Restart a VPN container."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    try:
+        manager.get_service(name)
+    except KeyError:
+        typer.echo(f"Service '{name}' not found.", err=True)
+        raise typer.Exit(1)
+
+    from .docker_ops import restart_container
+
+    try:
+        restart_container(name)
+        typer.echo(f"Restarted '{name}'.")
+    except NotFound:
+        typer.echo(f"Container '{name}' does not exist.", err=True)
+        raise typer.Exit(1)
+    except APIError as exc:
+        typer.echo(f"Failed to restart '{name}': {exc.explanation}", err=True)
+        raise typer.Exit(1)
+
+
+@vpn_app.command("logs")
+def vpn_logs(
+    name: str,
+    lines: int = typer.Option(100, "--lines", help="Number of lines to show"),
+    follow: bool = typer.Option(False, "--follow", help="Follow log output"),
+):
+    """Show logs for a VPN container."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    try:
+        manager.get_service(name)
+    except KeyError:
+        typer.echo(f"Service '{name}' not found.", err=True)
+        raise typer.Exit(1)
+
+    from .docker_ops import container_logs
+
+    try:
+        for line in container_logs(name, lines=lines, follow=follow):
+            typer.echo(line)
+    except NotFound:
+        typer.echo(f"Container '{name}' does not exist.", err=True)
+        raise typer.Exit(1)
+
+
+@vpn_app.command("delete")
+def vpn_delete(
+    name: str, force: bool = typer.Option(False, "--force", "-f", help="Do not prompt")
+):
+    """Delete a VPN service and remove its container."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    try:
+        manager.get_service(name)
+    except KeyError:
+        typer.echo(f"Service '{name}' not found.", err=True)
+        raise typer.Exit(1)
+
+    if not force and not typer.confirm(f"Delete service '{name}'?"):
+        raise typer.Exit()
+
+    from .docker_ops import remove_container, stop_container
+
+    try:
+        stop_container(name)
+    except NotFound:
+        pass
+    try:
+        remove_container(name)
+    except NotFound:
+        pass
+
+    manager.remove_service(name)
+    typer.echo(f"Service '{name}' deleted.")
+
+
+# ---------------------------------------------------------------------------
+# Bulk container commands
+# ---------------------------------------------------------------------------
+
+
+@bulk_app.command("up")
+def bulk_up():
+    """Start all VPN containers."""
+
+    from .docker_ops import start_all_vpn_containers
+
+    results = start_all_vpn_containers()
+    for name, started in results:
+        if started:
+            typer.echo(f"\u2713 Started {name}")
+        else:
+            typer.echo(f"\u2192 {name} already running")
+
+
+@bulk_app.command("down")
+def bulk_down():
+    """Stop all running VPN containers."""
+
+    from .docker_ops import stop_all_vpn_containers
+
+    results = stop_all_vpn_containers()
+    for name in results:
+        typer.echo(f"\u2713 Stopped {name}")
+
+
+@bulk_app.command("status")
+def bulk_status():
+    """Show status and IP address for VPN containers."""
+
+    from .docker_ops import get_vpn_containers, get_container_ip
+
+    containers = get_vpn_containers(all=True)
+    typer.echo(f"{'NAME':<15} {'STATUS':<10} {'PORT':<8} {'IP':<15}")
+    typer.echo("-" * 50)
+    for container in containers:
+        port = container.labels.get("vpn.port", "N/A")
+        ip = get_container_ip(container) if container.status == "running" else "N/A"
+        typer.echo(f"{container.name:<15} {container.status:<10} {port:<8} {ip:<15}")
+
+
+@bulk_app.command("ips")
+def bulk_ips():
+    """Show IP addresses of running VPN containers."""
+
+    from .docker_ops import get_vpn_containers, get_container_ip
+
+    containers = get_vpn_containers(all=False)
+    for container in containers:
+        ip = get_container_ip(container)
+        typer.echo(f"{container.name}: {ip}")
+
+
+# ---------------------------------------------------------------------------
+# Server commands
+# ---------------------------------------------------------------------------
+
+
+@server_app.command("update")
+def servers_update(
+    insecure: bool = typer.Option(
+        False,
+        "--insecure",
+        help="Disable SSL certificate verification (for troubleshooting)",
+    ),
+):
+    """Download and cache the latest server list."""
+
+    mgr = ServerManager()
+    verify = not insecure
+    mgr.update_servers(verify=verify)
+    typer.echo("Server list updated.")
+
+
+@server_app.command("list-providers")
+def servers_list_providers():
+    """List VPN providers from the cached server list."""
+
+    mgr = ServerManager()
+    for provider in mgr.list_providers():
+        typer.echo(provider)
+
+
+@server_app.command("list-countries")
+def servers_list_countries(provider: str):
+    """List countries for a VPN provider."""
+
+    mgr = ServerManager()
+    for country in mgr.list_countries(provider):
+        typer.echo(country)
+
+
+@server_app.command("list-cities")
+def servers_list_cities(provider: str, country: str):
+    """List cities for a VPN provider in a country."""
+
+    mgr = ServerManager()
+    for city in mgr.list_cities(provider, country):
+        typer.echo(city)
+
+
+@server_app.command("validate-location")
+def servers_validate_location(provider: str, location: str):
+    """Validate that a location exists for a provider."""
+
+    mgr = ServerManager()
+    if mgr.validate_location(provider, location):
+        typer.echo("valid")
+    else:
+        typer.echo("invalid", err=True)
+        raise typer.Exit(1)
+
+
+@preset_app.command("list")
+def preset_list():
+    """List available presets."""
+
+    from .preset_manager import list_available_presets
+
+    for preset in list_available_presets():
+        typer.echo(preset)
+
+
+@preset_app.command("apply")
+def preset_apply(
+    preset: str,
+    service: str,
+    port: int = typer.Option(0, help="Host port to expose; 0 for auto"),
+):
+    """Create a VPN service from a preset."""
+
+    manager = ComposeManager(config.COMPOSE_FILE)
+    if port == 0:
+        port = manager.next_available_port(config.DEFAULT_PORT_START)
+    from .preset_manager import apply_preset
+
+    apply_preset(preset, service, port)
+    typer.echo(f"Service '{service}' created from preset '{preset}' on port {port}.")
+
+
+@app.command("test")
+def test(service: str):
+    """Test that a VPN service proxy is working."""
+
+    from .docker_ops import test_vpn_connection
+
+    if test_vpn_connection(service):
+        typer.echo("VPN connection is active.")
+    else:
+        typer.echo("VPN connection failed.", err=True)
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

proxy2vpn/compose_manager.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List
+
+from ruamel.yaml import YAML
+from ruamel.yaml.comments import CommentedMap
+
+from .models import Profile, VPNService
+
+
+class ComposeManager:
+    """Manage docker-compose files for VPN services."""
+
+    def __init__(self, compose_path: Path) -> None:
+        self.compose_path = compose_path
+        self.yaml = YAML()
+        self.data: Dict[str, Any] = self._load()
+
+    def _load(self) -> Dict[str, Any]:
+        with self.compose_path.open("r", encoding="utf-8") as f:
+            return self.yaml.load(f)
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        """Return global configuration stored under x-config."""
+        return self.data.get("x-config", {})
+
+    def list_services(self) -> List[VPNService]:
+        services = self.data.get("services", {})
+        return [
+            VPNService.from_compose_service(name, svc) for name, svc in services.items()
+        ]
+
+    def get_service(self, name: str) -> VPNService:
+        services = self.data.get("services", {})
+        if name not in services:
+            raise KeyError(f"Service '{name}' not found")
+        return VPNService.from_compose_service(name, services[name])
+
+    def add_service(self, service: VPNService) -> None:
+        services = self.data.setdefault("services", {})
+        if service.name in services:
+            raise ValueError(f"Service '{service.name}' already exists")
+        profile_key = f"x-vpn-base-{service.profile}"
+        profile_map = self.data.get(profile_key)
+        if profile_map is None:
+            raise KeyError(f"Profile '{service.profile}' not found")
+        svc_map = CommentedMap(service.to_compose_service())
+        svc_map.merge_attrib = [profile_map]
+        services[service.name] = svc_map
+        self.save()
+
+    def remove_service(self, name: str) -> None:
+        services = self.data.get("services", {})
+        if name not in services:
+            raise KeyError(f"Service '{name}' not found")
+        del services[name]
+        self.save()
+
+    # ------------------------------------------------------------------
+    # Profile management
+    # ------------------------------------------------------------------
+
+    def list_profiles(self) -> List[Profile]:
+        profiles: List[Profile] = []
+        for key, value in self.data.items():
+            if key.startswith("x-vpn-base-"):
+                name = key[len("x-vpn-base-") :]
+                profiles.append(Profile.from_anchor(name, value))
+        return profiles
+
+    def get_profile(self, name: str) -> Profile:
+        key = f"x-vpn-base-{name}"
+        if key not in self.data:
+            raise KeyError(f"Profile '{name}' not found")
+        return Profile.from_anchor(name, self.data[key])
+
+    def add_profile(self, profile: Profile) -> None:
+        key = f"x-vpn-base-{profile.name}"
+        if key in self.data:
+            raise ValueError(f"Profile '{profile.name}' already exists")
+        anchor_map = CommentedMap(profile.to_anchor())
+        anchor_map.yaml_set_anchor(f"vpn-base-{profile.name}", always_dump=True)
+        self.data[key] = anchor_map
+        self.save()
+
+    def remove_profile(self, name: str) -> None:
+        key = f"x-vpn-base-{name}"
+        if key not in self.data:
+            raise KeyError(f"Profile '{name}' not found")
+        del self.data[key]
+        self.save()
+
+    # ------------------------------------------------------------------
+    # Utility helpers
+    # ------------------------------------------------------------------
+
+    def next_available_port(self, start: int = 0) -> int:
+        """Find the next available host port starting from START.
+
+        If START is 0 the search begins from 20000 which is the default
+        range used by proxy2vpn.  Existing service ports are inspected and
+        the first free port is returned.
+        """
+
+        port = start or 20000
+        used = {svc.port for svc in self.list_services()}
+        while port in used:
+            port += 1
+        return port
+
+    def save(self) -> None:
+        with self.compose_path.open("w", encoding="utf-8") as f:
+            self.yaml.dump(self.data, f)

proxy2vpn/compose_utils.py

@@ -0,0 +1,38 @@
+"""Utilities for manipulating docker-compose YAML files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ruamel.yaml import YAML
+
+yaml = YAML()
+
+
+def load_compose(path: Path) -> dict[str, Any]:
+    """Load a docker-compose YAML file."""
+    with path.open("r", encoding="utf-8") as f:
+        return yaml.load(f)
+
+
+def save_compose(data: dict[str, Any], path: Path) -> None:
+    """Save a docker-compose YAML file."""
+    with path.open("w", encoding="utf-8") as f:
+        yaml.dump(data, f)
+
+
+def set_service_image(compose_path: Path, service: str, image: str) -> None:
+    """Update the image of a service in the compose file.
+
+    Args:
+        compose_path: Path to the docker-compose.yml file.
+        service: Name of the service to update.
+        image: New image string.
+    """
+    data = load_compose(compose_path)
+    services = data.get("services", {})
+    if service not in services:
+        raise KeyError(f"Service '{service}' not found")
+    services[service]["image"] = image
+    save_compose(data, compose_path)

proxy2vpn/config.py

@@ -0,0 +1,34 @@
+"""Default configuration for proxy2vpn.
+
+This module centralizes paths and default values used across the
+application.  All state is stored in the docker compose file referenced
+by :data:`COMPOSE_FILE`.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# Path to the docker compose file that acts as the single source of truth
+# for all proxy2vpn state.  The path is relative to the current working
+# directory of the CLI unless an absolute path is provided by the user.
+COMPOSE_FILE: Path = Path("compose.yml")
+
+# Directory used to cache data such as the downloaded server lists.  The
+# cache location defaults to ``~/.cache/proxy2vpn`` which follows the
+# XDG base directory specification on Linux systems.
+CACHE_DIR: Path = Path.home() / ".cache" / "proxy2vpn"
+
+# Default VPN provider used when creating new services if none is
+# explicitly specified by the user.
+DEFAULT_PROVIDER = "protonvpn"
+
+# Starting port used when automatically allocating ports for new VPN
+# services.  The manager will search for the next free port starting from
+# this value.
+DEFAULT_PORT_START = 20000
+
+# URL of the gluetun server list JSON file.  This file is fetched and
+# cached by :class:`ServerManager` to provide location validation and
+# listing of available servers.
+SERVER_LIST_URL = "https://raw.githubusercontent.com/qdm12/gluetun/master/internal/storage/servers.json"