plexo-cli 0.1.0__py3-none-any.whl

plexo/__init__.py

@@ -0,0 +1,4 @@
+"""Plexo CLI: Multi-network bandwidth bonding download accelerator."""
+
+__version__ = "0.1.0"
+__author__ = "Jagjot Singh"

plexo/cli.py

@@ -0,0 +1,190 @@
+"""Command Line Interface for Plexo.
+
+Exposes subcommands: download, adapters, proxy, info.
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+# Ensure UTF-8 output on Windows consoles
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from . import __version__
+from .core.adapter import discover_adapters, get_bonded_pool
+from .core.engine import BondingDownloadEngine, ProgressUpdate
+from .proxy.server import run_proxy
+from .ui.dashboard import TerminalDashboard
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="plexo")
+def main():
+    """Plexo: Multi-Network Bandwidth Bonding Download Engine."""
+    pass
+
+
+@main.command(name="adapters")
+@click.option("--all", "show_all", is_flag=True, help="Show all adapters including offline/internal.")
+def list_adapters(show_all: bool):
+    """Scan and benchmark active network adapters."""
+    console.print("\n[bold cyan]Scanning Network Interfaces...[/bold cyan]")
+    adapters = discover_adapters(verify_online=True)
+
+    table = Table(title="[bold green]Network Interfaces[/bold green]")
+    table.add_column("Interface Name", style="bold white")
+    table.add_column("Type", style="magenta")
+    table.add_column("IPv4 Address", style="cyan")
+    table.add_column("Link Speed", style="yellow")
+    table.add_column("Internet Route", style="bold")
+
+    display_list = adapters if show_all else [a for a in adapters if a.is_online]
+
+    for a in display_list:
+        status_text = "[bold green]ONLINE[/bold green]" if a.is_online else "[dim red]OFFLINE[/dim red]"
+        speed_str = f"{a.speed_mbps} Mbps" if a.speed_mbps > 0 else "Unknown"
+        table.add_row(a.name, a.kind.upper(), a.ip_address, speed_str, status_text)
+
+    console.print(table)
+    online_count = sum(1 for a in adapters if a.is_online)
+
+    if online_count >= 2:
+        console.print(
+            f"\n[bold green][OK] Ready for bonding:[/bold green] [yellow]{online_count}[/yellow] independent connections detected.\n"
+        )
+    elif online_count == 1:
+        console.print(
+            "\n[yellow][INFO] 1 connection active.[/yellow] Plug in Phone 5G USB tethering or Ethernet to enable multi-network bonding.\n"
+        )
+    else:
+        console.print("\n[bold red][X] No online connections found.[/bold red]\n")
+
+
+@main.command(name="download")
+@click.argument("url")
+@click.option("-o", "--output", "output_path", type=click.Path(), default=None, help="Output destination path.")
+@click.option("--chunk-size", default=8, type=int, help="Chunk size in MB (default: 8 MB).")
+@click.option("--workers", default=2, type=int, help="Workers per network adapter (default: 2).")
+def download_file(url: str, output_path: Optional[str], chunk_size: int, workers: int):
+    """Download a file using bonded multi-network connections."""
+    adapters = get_bonded_pool()
+    if not adapters:
+        console.print("[bold red]Error: No active online network adapters detected.[/bold red]")
+        raise click.Abort()
+
+    dashboard = TerminalDashboard(console=console)
+    chunk_bytes = chunk_size * 1024 * 1024
+
+    engine = BondingDownloadEngine(
+        url=url,
+        output_path=output_path,
+        adapters=adapters,
+        chunk_size=chunk_bytes,
+        workers_per_adapter=workers,
+    )
+
+    probe = engine._prepare()
+    dashboard.setup(probe.filename, probe.total_bytes, adapters)
+
+    start_time = time.time()
+    with dashboard.progress:
+        final_path = engine.execute(progress_callback=dashboard.update)
+
+    elapsed = time.time() - start_time
+    total_bytes = final_path.stat().st_size
+
+    # Calculate checksum
+    from .core.sparse import SparseFileWriter
+    with SparseFileWriter(final_path, total_bytes) as writer:
+        checksum = writer.calculate_checksum()
+
+    dashboard.finish(final_path.name, total_bytes, elapsed, checksum)
+
+
+@main.command(name="proxy")
+@click.option("--host", default="127.0.0.1", help="Proxy listening host (default: 127.0.0.1).")
+@click.option("--port", default=8899, type=int, help="Proxy listening port (default: 8899).")
+def start_proxy(host: str, port: int):
+    """Launch local acceleration proxy for pip, git, and curl."""
+    run_proxy(host=host, port=port)
+
+
+@main.command(name="torrent")
+@click.argument("source")
+@click.option("-o", "--output-dir", default=".", help="Directory to save downloaded files.")
+def download_torrent(source: str, output_dir: str):
+    """Download a torrent or magnet link across bonded network adapters."""
+    from .torrent.metadata import parse_magnet, parse_torrent_file
+    from .torrent.client import TorrentBondingEngine
+
+    adapters = get_bonded_pool()
+    if not adapters:
+        console.print("[bold red]Error: No active online network adapters detected.[/bold red]")
+        raise click.Abort()
+
+    if source.startswith("magnet:?"):
+        meta = parse_magnet(source)
+    else:
+        meta = parse_torrent_file(source)
+
+    console.print(
+        Panel.fit(
+            f"[bold cyan]Plexo Torrent Swarm Engine[/bold cyan]\n"
+            f"Name: [bold yellow]{meta.name}[/bold yellow]\n"
+            f"Info Hash: [dim]{meta.info_hash_hex}[/dim]\n"
+            f"Active Network Links: [bold green]{len(adapters)}[/bold green]",
+            border_style="cyan",
+        )
+    )
+
+    dashboard = TerminalDashboard(console=console)
+    dashboard.setup(meta.name, meta.total_length, adapters)
+
+    engine = TorrentBondingEngine(metadata=meta, output_dir=output_dir, adapters=adapters)
+
+    start_time = time.time()
+    with dashboard.progress:
+        final_path = engine.download(progress_callback=dashboard.update)
+
+    elapsed = time.time() - start_time
+    total_bytes = final_path.stat().st_size
+
+    from .core.sparse import SparseFileWriter
+    with SparseFileWriter(final_path, total_bytes) as writer:
+        checksum = writer.calculate_checksum()
+
+    dashboard.finish(final_path.name, total_bytes, elapsed, checksum)
+
+
+@main.command(name="info")
+def show_info():
+    """Display Plexo environment and bonding capabilities."""
+    adapters = get_bonded_pool()
+    console.print(
+        Panel.fit(
+            f"[bold cyan]Plexo CLI v{__version__}[/bold cyan]\n"
+            f"Bonding Engine: [bold green]Active[/bold green]\n"
+            f"Verified Online Adapters: [bold yellow]{len(adapters)}[/bold yellow]\n"
+            f"Default Proxy Port: [bold magenta]8899[/bold magenta]",
+            border_style="cyan",
+            title="System Capabilities",
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

plexo/core/__init__.py

@@ -0,0 +1 @@
+"""Core multi-adapter bonding and download engine."""

plexo/core/adapter.py

@@ -0,0 +1,139 @@
+"""Network interface discovery and binding module.
+
+Detects active network adapters (Wi-Fi, USB cellular tether, Ethernet),
+filters internal/virtual networks, and verifies outward internet reachability.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import platform
+import socket
+import subprocess
+from dataclasses import dataclass
+from typing import List, Optional
+import psutil
+import urllib3
+
+
+@dataclass
+class NetworkAdapter:
+    """Represents a discovered physical or virtual network interface."""
+    name: str
+    ip_address: str
+    netmask: str
+    kind: str  # "wifi", "usb", "ethernet", "other"
+    is_up: bool
+    speed_mbps: int = 0
+    gateway: Optional[str] = None
+    is_online: bool = False
+
+    @property
+    def display_name(self) -> str:
+        kind_label = self.kind.upper()
+        return f"{self.name} [{kind_label}] ({self.ip_address})"
+
+
+def classify_interface(name: str) -> str:
+    """Classifies interface type based on OS naming conventions."""
+    name_lower = name.lower()
+    if any(k in name_lower for k in ("wi-fi", "wifi", "wireless", "wlan", "802.11")):
+        return "wifi"
+    if any(k in name_lower for k in ("rndis", "tether", "remote ndis", "apple mobile", "usb", "enx")):
+        return "usb"
+    if any(k in name_lower for k in ("ethernet", "lan", "eth", "en0", "en1")):
+        return "ethernet"
+    return "other"
+
+
+def is_usable_ip(ip_str: str) -> bool:
+    """Checks if an IPv4 address is routable and not loopback/link-local."""
+    try:
+        ip = ipaddress.IPv4Address(ip_str)
+        if ip.is_loopback:
+            return False
+        if ip.is_link_local:  # 169.254.x.x
+            return False
+        if ip.is_unspecified:  # 0.0.0.0
+            return False
+        return True
+    except (ValueError, ipaddress.AddressValueError):
+        return False
+
+
+def test_adapter_connectivity(ip_address: str, timeout: float = 2.0) -> bool:
+    """Verifies that an outgoing connection bound to this source IP can reach the internet."""
+    test_hosts = [("1.1.1.1", 53), ("8.8.8.8", 53)]
+    for host, port in test_hosts:
+        sock = None
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(timeout)
+            # Bind specifically to this adapter's source IP
+            sock.bind((ip_address, 0))
+            sock.connect((host, port))
+            return True
+        except (socket.error, OSError):
+            continue
+        finally:
+            if sock:
+                sock.close()
+    return False
+
+
+def discover_adapters(verify_online: bool = True) -> List[NetworkAdapter]:
+    """Discovers all active, routable network adapters."""
+    adapters: List[NetworkAdapter] = []
+    seen_ips = set()
+
+    if_addrs = psutil.net_if_addrs()
+    if_stats = psutil.net_if_stats()
+
+    # Exclude common internal virtual switches unless they provide genuine routes
+    virtual_keywords = ("vEthernet", "Hyper-V", "VirtualBox", "VMware", "Loopback", "WSL")
+
+    for iface_name, addrs in if_addrs.items():
+        if any(v.lower() in iface_name.lower() for v in virtual_keywords):
+            continue
+
+        stats = if_stats.get(iface_name)
+        is_up = stats.isup if stats else True
+        if not is_up:
+            continue
+
+        for addr in addrs:
+            # We focus on IPv4 for multi-adapter bonding
+            if addr.family == socket.AF_INET:
+                ip = addr.address
+                if ip in seen_ips or not is_usable_ip(ip):
+                    continue
+
+                seen_ips.add(ip)
+                kind = classify_interface(iface_name)
+                speed = stats.speed if stats else 0
+
+                online = False
+                if verify_online:
+                    online = test_adapter_connectivity(ip)
+
+                adapter = NetworkAdapter(
+                    name=iface_name,
+                    ip_address=ip,
+                    netmask=addr.netmask or "255.255.255.0",
+                    kind=kind,
+                    is_up=is_up,
+                    speed_mbps=speed,
+                    is_online=online if verify_online else is_up,
+                )
+                adapters.append(adapter)
+
+    # Sort so online adapters appear first, prioritized by speed/type
+    adapters.sort(key=lambda a: (not a.is_online, a.kind == "other", a.name))
+    return adapters
+
+
+def get_bonded_pool(min_adapters: int = 1) -> List[NetworkAdapter]:
+    """Returns all verified online adapters ready for bonding."""
+    adapters = discover_adapters(verify_online=True)
+    online = [a for a in adapters if a.is_online]
+    return online if online else adapters

plexo/core/client.py

@@ -0,0 +1,148 @@
+"""HTTP probe and socket-bound range request client.
+
+Inspects remote servers for Range support and executes chunk transfers
+strictly bound to designated local adapter IP addresses.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from typing import Callable, Generator, Optional
+from urllib.parse import unquote, urlparse
+import urllib3
+from urllib3.util import parse_url
+
+
+@dataclass
+class ProbeResult:
+    """Metadata retrieved from probing the target URL."""
+    url: str
+    total_bytes: int
+    accepts_ranges: bool
+    filename: str
+    content_type: str
+    etag: Optional[str] = None
+
+
+def extract_filename(url: str, content_disposition: Optional[str] = None) -> str:
+    """Deduces filename from Content-Disposition header or URL path."""
+    if content_disposition:
+        # Match filename="example.zip" or filename*=UTF-8''example.zip
+        match = re.search(r'filename\*?=(?:UTF-8\'\')?["\']?([^"\';]+)["\']?', content_disposition, re.IGNORECASE)
+        if match:
+            return os.path.basename(unquote(match.group(1).strip()))
+
+    parsed = urlparse(url)
+    path_name = os.path.basename(unquote(parsed.path))
+    if path_name and "." in path_name:
+        return path_name
+
+    return "downloaded_file.bin"
+
+
+def probe_url(url: str, timeout: float = 10.0) -> ProbeResult:
+    """Probes the remote server to determine file size, range support, and filename."""
+    http = urllib3.PoolManager()
+    headers = {
+        "User-Agent": "Plexo-CLI/0.1.0 (Bandwidth-Bonding-Engine)",
+        "Accept-Encoding": "identity",
+    }
+
+    try:
+        # First attempt with HEAD
+        resp = http.request("HEAD", url, headers=headers, timeout=timeout, redirect=True)
+        if resp.status >= 400:
+            # Fallback to GET with 1 byte range if HEAD is blocked
+            headers["Range"] = "bytes=0-0"
+            resp = http.request("GET", url, headers=headers, timeout=timeout, redirect=True)
+    except Exception:
+        # Fallback to GET with range
+        headers["Range"] = "bytes=0-0"
+        resp = http.request("GET", url, headers=headers, timeout=timeout, redirect=True)
+
+    final_url = url
+    if hasattr(resp, "url") and resp.url:
+        candidate_url = resp.url
+        if candidate_url.startswith("http://") or candidate_url.startswith("https://"):
+            final_url = candidate_url
+    headers_resp = resp.headers
+
+    # Check range support
+    accepts_ranges = False
+    if resp.status == 206:
+        accepts_ranges = True
+    elif headers_resp.get("Accept-Ranges", "").lower() == "bytes":
+        accepts_ranges = True
+
+    # Determine total size
+    total_bytes = 0
+    content_range = headers_resp.get("Content-Range")
+    if content_range:
+        # format: bytes 0-0/104857600
+        match = re.search(r"/(\d+)", content_range)
+        if match:
+            total_bytes = int(match.group(1))
+            accepts_ranges = True
+
+    if not total_bytes:
+        cl = headers_resp.get("Content-Length")
+        if cl and cl.isdigit():
+            total_bytes = int(cl)
+
+    cd = headers_resp.get("Content-Disposition")
+    filename = extract_filename(final_url, cd)
+    content_type = headers_resp.get("Content-Type", "application/octet-stream")
+    etag = headers_resp.get("ETag")
+
+    return ProbeResult(
+        url=final_url,
+        total_bytes=total_bytes,
+        accepts_ranges=accepts_ranges,
+        filename=filename,
+        content_type=content_type,
+        etag=etag,
+    )
+
+
+class BoundRangeClient:
+    """Performs HTTP GET range downloads strictly bound to a local adapter IP."""
+
+    def __init__(self, local_ip: str, timeout: float = 15.0):
+        self.local_ip = local_ip
+        self.timeout = timeout
+        # Bind urllib3 socket connections to (local_ip, 0)
+        self._pool = urllib3.PoolManager(
+            source_address=(local_ip, 0),
+            timeout=urllib3.Timeout(connect=timeout, read=timeout),
+            retries=urllib3.Retry(total=3, backoff_factor=0.5),
+        )
+
+    def fetch_range(
+        self,
+        url: str,
+        start_byte: int,
+        end_byte: int,
+        chunk_size: int = 64 * 1024,  # 64 KB read buffer
+        on_bytes: Optional[Callable[[int], None]] = None,
+    ) -> Generator[bytes, None, None]:
+        """Fetches [start_byte, end_byte] inclusive through the bound adapter."""
+        headers = {
+            "User-Agent": "Plexo-CLI/0.1.0 (Bandwidth-Bonding-Engine)",
+            "Range": f"bytes={start_byte}-{end_byte}",
+            "Accept-Encoding": "identity",
+        }
+
+        resp = self._pool.request("GET", url, headers=headers, preload_content=False)
+        try:
+            if resp.status not in (200, 206):
+                raise IOError(f"HTTP Range request failed with status {resp.status}")
+
+            for data in resp.stream(chunk_size):
+                if data:
+                    if on_bytes:
+                        on_bytes(len(data))
+                    yield data
+        finally:
+            resp.release_conn()