localstream 1.0.0__tar.gz

localstream-1.0.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: localstream
+Version: 1.0.0
+Summary: Python CLI client for slipstream-rust DNS tunnel
+Author: LocalStream Team
+License: MIT
+Keywords: dns,tunnel,vpn,slipstream,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: Proxy Servers
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: colorama>=0.4.6
+
+# LocalStream
+
+A Python command-line client for [slipstream-rust](https://github.com/Mygod/slipstream-rust) DNS tunnel.
+
+## Features
+
+- **VPN Mode**: System-wide traffic tunneling (requires Admin)
+- **PROXY Mode**: SOCKS5 proxy on local port
+- Auto-reconnect on connection drops
+- Easy pip installation
+- Colorful CLI interface
+
+## Requirements
+
+- Python 3.13+
+- Windows OS
+- Administrator privileges (for VPN Mode)
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+LocalStream          # Normal user (PROXY mode only)
+# Run as Administrator for VPN mode
+```
+
+### Menu Options
+
+```
+[1] Connect to server
+    ├── [1] VPN Mode   (system-wide, requires Admin)
+    ├── [2] PROXY Mode (SOCKS5 only)
+    └── [3] Back
+[2] Edit configuration
+[3] Exit
+```
+
+### Keyboard Shortcuts
+
+- **Ctrl+C**: Disconnect and exit
+- **Ctrl+D**: Restart connection
+
+## Configuration
+
+Config stored in `~/.localstream/config.json`:
+
+```json
+{
+  "server_ip": "203.0.113.2",
+  "server_port": 53,
+  "local_port": 5201,
+  "domain": "s.example.com"
+}
+```
+
+## Downloaded Binaries
+
+Stored in `~/.localstream/bin/`:
+- `slipstream-client.exe` - DNS tunnel client
+- `tun2proxy.exe` - TUN adapter for VPN mode
+- `wintun.dll` - Windows TUN driver
+
+## License
+
+MIT

localstream-1.0.0/README.md

@@ -0,0 +1,70 @@
+# LocalStream
+
+A Python command-line client for [slipstream-rust](https://github.com/Mygod/slipstream-rust) DNS tunnel.
+
+## Features
+
+- **VPN Mode**: System-wide traffic tunneling (requires Admin)
+- **PROXY Mode**: SOCKS5 proxy on local port
+- Auto-reconnect on connection drops
+- Easy pip installation
+- Colorful CLI interface
+
+## Requirements
+
+- Python 3.13+
+- Windows OS
+- Administrator privileges (for VPN Mode)
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+LocalStream          # Normal user (PROXY mode only)
+# Run as Administrator for VPN mode
+```
+
+### Menu Options
+
+```
+[1] Connect to server
+    ├── [1] VPN Mode   (system-wide, requires Admin)
+    ├── [2] PROXY Mode (SOCKS5 only)
+    └── [3] Back
+[2] Edit configuration
+[3] Exit
+```
+
+### Keyboard Shortcuts
+
+- **Ctrl+C**: Disconnect and exit
+- **Ctrl+D**: Restart connection
+
+## Configuration
+
+Config stored in `~/.localstream/config.json`:
+
+```json
+{
+  "server_ip": "203.0.113.2",
+  "server_port": 53,
+  "local_port": 5201,
+  "domain": "s.example.com"
+}
+```
+
+## Downloaded Binaries
+
+Stored in `~/.localstream/bin/`:
+- `slipstream-client.exe` - DNS tunnel client
+- `tun2proxy.exe` - TUN adapter for VPN mode
+- `wintun.dll` - Windows TUN driver
+
+## License
+
+MIT

localstream-1.0.0/localstream/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

localstream-1.0.0/localstream/__main__.py

@@ -0,0 +1,4 @@
+from localstream.cli import main
+
+if __name__ == "__main__":
+    main()

localstream-1.0.0/localstream/cli.py

@@ -0,0 +1,321 @@
+import sys
+import os
+
+try:
+    import colorama
+    colorama.init()
+except ImportError:
+    pass
+
+from localstream.config import config_exists, load_config, save_config, get_default_config
+from localstream.connection import ConnectionManager, is_admin
+from localstream.downloader import client_exists, download_client, tun2proxy_exists, download_tun2proxy
+
+
+CYAN = "\033[96m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+RED = "\033[91m"
+MAGENTA = "\033[95m"
+BLUE = "\033[94m"
+WHITE = "\033[97m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+
+LOGO = f"""
+{CYAN}╔═══════════════════════════════════════════════════════════════╗
+║                                                               ║
+║  {MAGENTA}██╗      ██████╗  ██████╗ █████╗ ██╗     {CYAN}                    ║
+║  {MAGENTA}██║     ██╔═══██╗██╔════╝██╔══██╗██║     {CYAN}                    ║
+║  {MAGENTA}██║     ██║   ██║██║     ███████║██║     {CYAN}                    ║
+║  {MAGENTA}██║     ██║   ██║██║     ██╔══██║██║     {CYAN}                    ║
+║  {MAGENTA}███████╗╚██████╔╝╚██████╗██║  ██║███████╗{CYAN}                    ║
+║  {MAGENTA}╚══════╝ ╚═════╝  ╚═════╝╚═╝  ╚═╝╚══════╝{CYAN}                    ║
+║                                                               ║
+║  {BLUE}███████╗████████╗██████╗ ███████╗ █████╗ ███╗   ███╗{CYAN}         ║
+║  {BLUE}██╔════╝╚══██╔══╝██╔══██╗██╔════╝██╔══██╗████╗ ████║{CYAN}         ║
+║  {BLUE}███████╗   ██║   ██████╔╝█████╗  ███████║██╔████╔██║{CYAN}         ║
+║  {BLUE}╚════██║   ██║   ██╔══██╗██╔══╝  ██╔══██║██║╚██╔╝██║{CYAN}         ║
+║  {BLUE}███████║   ██║   ██║  ██║███████╗██║  ██║██║ ╚═╝ ██║{CYAN}         ║
+║  {BLUE}╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝{CYAN}         ║
+║                                                               ║
+║         {DIM}SlipStream DNS Tunnel • Python CLI Client{CYAN}             ║
+╚═══════════════════════════════════════════════════════════════╝{RESET}
+"""
+
+MINI_LOGO = f"""
+{CYAN}╔═══════════════════════════════════════════╗
+║  {MAGENTA}LocalStream{CYAN} • {DIM}SlipStream CLI Client{CYAN}      ║
+╚═══════════════════════════════════════════╝{RESET}
+"""
+
+
+def clear_screen():
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+def print_logo(mini: bool = False):
+    if mini:
+        print(MINI_LOGO)
+    else:
+        print(LOGO)
+
+
+def print_box(title: str, content: list, color: str = CYAN):
+    max_len = max(len(line) for line in content) if content else 20
+    max_len = max(max_len, len(title) + 4)
+    width = max_len + 4
+    
+    print(f"\n{color}┌{'─' * width}┐{RESET}")
+    print(f"{color}│{RESET}  {BOLD}{title}{RESET}{' ' * (width - len(title) - 2)}{color}│{RESET}")
+    print(f"{color}├{'─' * width}┤{RESET}")
+    
+    for line in content:
+        padding = width - len(line) - 2
+        print(f"{color}│{RESET}  {line}{' ' * padding}{color}│{RESET}")
+    
+    print(f"{color}└{'─' * width}┘{RESET}")
+
+
+def print_config(config: dict):
+    server = f"{config.get('server_ip', 'N/A')}:{config.get('server_port', 53)}"
+    admin_status = f"{GREEN}✓ Admin{RESET}" if is_admin() else f"{YELLOW}○ User{RESET}"
+    content = [
+        f"{GREEN}●{RESET} Server     : {WHITE}{server}{RESET}",
+        f"{GREEN}●{RESET} Domain     : {WHITE}{config.get('domain', 'N/A')}{RESET}",
+        f"{GREEN}●{RESET} Local Port : {WHITE}{config.get('local_port', 5201)}{RESET}",
+        f"{DIM}─────────────────────────────────{RESET}",
+        f"{BLUE}●{RESET} Status     : {admin_status}",
+    ]
+    print_box("Current Configuration", content, CYAN)
+
+
+def print_main_menu():
+    content = [
+        f"{YELLOW}[1]{RESET}  Connect to server",
+        f"{YELLOW}[2]{RESET}  Edit configuration",
+        f"{YELLOW}[3]{RESET}  Exit",
+    ]
+    print_box("Menu", content, BLUE)
+
+
+def print_connection_menu():
+    vpn_status = f"{GREEN}●{RESET}" if is_admin() else f"{RED}○{RESET}"
+    admin_note = "" if is_admin() else f" {DIM}(requires Admin){RESET}"
+    content = [
+        f"{YELLOW}[1]{RESET}  {vpn_status} VPN Mode   {DIM}(system-wide){RESET}{admin_note}",
+        f"{YELLOW}[2]{RESET}  {GREEN}●{RESET} PROXY Mode {DIM}(SOCKS5 only){RESET}",
+        f"{YELLOW}[3]{RESET}  Back to menu",
+    ]
+    print_box("Connection Mode", content, MAGENTA)
+
+
+def get_input(prompt: str, default: str = "") -> str:
+    if default:
+        result = input(f"  {GREEN}▸{RESET} {prompt} {DIM}[{default}]{RESET}: ").strip()
+        return result if result else default
+    return input(f"  {GREEN}▸{RESET} {prompt}: ").strip()
+
+
+def get_int_input(prompt: str, default: int) -> int:
+    while True:
+        result = input(f"  {GREEN}▸{RESET} {prompt} {DIM}[{default}]{RESET}: ").strip()
+        if not result:
+            return default
+        try:
+            return int(result)
+        except ValueError:
+            print(f"  {RED}✗{RESET} Please enter a valid number")
+
+
+def prompt_for_config() -> dict:
+    print(f"\n{YELLOW}━━━ Server Configuration ━━━{RESET}\n")
+    
+    config = get_default_config()
+    
+    while True:
+        server_ip = get_input("Server IP (e.g., 203.0.113.2)")
+        if server_ip:
+            config["server_ip"] = server_ip
+            break
+        print(f"  {RED}✗{RESET} Server IP is required")
+    
+    config["server_port"] = get_int_input("Server Port", 53)
+    config["local_port"] = get_int_input("Local Port", 5201)
+    
+    while True:
+        domain = get_input("Domain (e.g., s.example.com)")
+        if domain:
+            config["domain"] = domain
+            break
+        print(f"  {RED}✗{RESET} Domain is required")
+    
+    return config
+
+
+def show_main_menu() -> int:
+    print_main_menu()
+    print()
+    
+    while True:
+        try:
+            choice = input(f"  {MAGENTA}▸{RESET} Select option {DIM}[1-3]{RESET}: ").strip()
+            if choice in ["1", "2", "3"]:
+                return int(choice)
+            print(f"  {RED}✗{RESET} Please enter 1, 2, or 3")
+        except (ValueError, EOFError):
+            return 3
+
+
+def show_connection_menu() -> int:
+    print_connection_menu()
+    print()
+    
+    while True:
+        try:
+            choice = input(f"  {MAGENTA}▸{RESET} Select mode {DIM}[1-3]{RESET}: ").strip()
+            if choice in ["1", "2", "3"]:
+                return int(choice)
+            print(f"  {RED}✗{RESET} Please enter 1, 2, or 3")
+        except (ValueError, EOFError):
+            return 3
+
+
+def print_connecting_banner(config: dict, mode: str):
+    server = f"{config.get('server_ip')}:{config.get('server_port')}"
+    domain = config.get('domain')
+    local_port = config.get('local_port')
+    mode_display = f"{GREEN}VPN{RESET}" if mode == "vpn" else f"{BLUE}PROXY{RESET}"
+    
+    print(f"\n{CYAN}╔═══════════════════════════════════════════════════════╗{RESET}")
+    print(f"{CYAN}║{RESET}  {GREEN}●{RESET} {BOLD}Connecting in {mode_display} Mode...{RESET}{' ' * 24}{CYAN}║{RESET}")
+    print(f"{CYAN}╟───────────────────────────────────────────────────────╢{RESET}")
+    print(f"{CYAN}║{RESET}  Resolver   : {WHITE}{server:<38}{RESET}{CYAN}║{RESET}")
+    print(f"{CYAN}║{RESET}  Domain     : {WHITE}{domain:<38}{RESET}{CYAN}║{RESET}")
+    print(f"{CYAN}║{RESET}  Local Port : {WHITE}{local_port:<38}{RESET}{CYAN}║{RESET}")
+    print(f"{CYAN}╟───────────────────────────────────────────────────────╢{RESET}")
+    print(f"{CYAN}║{RESET}  {DIM}Press Ctrl+C to disconnect • Ctrl+D to restart{RESET}      {CYAN}║{RESET}")
+    print(f"{CYAN}╚═══════════════════════════════════════════════════════╝{RESET}\n")
+
+
+def handle_first_run():
+    clear_screen()
+    print_logo()
+    
+    print(f"\n{GREEN}✓{RESET} Welcome to LocalStream!")
+    print(f"{DIM}  First-time setup - Let's configure your connection{RESET}\n")
+    
+    if not client_exists():
+        print(f"\n{YELLOW}⟳{RESET} Downloading slipstream-client...")
+        if not download_client():
+            print(f"\n{RED}✗{RESET} Failed to download client. Check your internet connection.")
+            sys.exit(1)
+        print(f"{GREEN}✓{RESET} Download complete!\n")
+    
+    config = prompt_for_config()
+    save_config(config)
+    print(f"\n{GREEN}✓{RESET} Configuration saved!")
+    
+    print_config(config)
+    
+    input(f"\n  {DIM}Press Enter to continue to menu...{RESET}")
+    handle_menu()
+
+
+def handle_connection(config: dict, mode: str):
+    while True:
+        clear_screen()
+        print_logo(mini=True)
+        print_connecting_banner(config, mode)
+        
+        manager = ConnectionManager()
+        
+        if mode == "vpn":
+            result = manager.connect_vpn(config)
+        else:
+            result = manager.connect_proxy(config)
+        
+        if result == "restart":
+            print(f"\n{YELLOW}⟳{RESET} Restarting connection...")
+            continue
+        break
+
+
+def handle_menu():
+    while True:
+        clear_screen()
+        print_logo()
+        
+        config = load_config()
+        print_config(config)
+        
+        choice = show_main_menu()
+        
+        if choice == 1:
+            clear_screen()
+            print_logo(mini=True)
+            print_config(config)
+            
+            mode_choice = show_connection_menu()
+            
+            if mode_choice == 1:
+                if not is_admin():
+                    print(f"\n{RED}✗{RESET} VPN Mode requires Administrator privileges!")
+                    print(f"{YELLOW}!{RESET} Please restart LocalStream as Administrator")
+                    input(f"\n  {DIM}Press Enter to continue...{RESET}")
+                    continue
+                
+                if not tun2proxy_exists():
+                    print(f"\n{YELLOW}⟳{RESET} Downloading VPN components...")
+                    if not download_tun2proxy():
+                        print(f"\n{RED}✗{RESET} Failed to download VPN components.")
+                        input(f"\n  {DIM}Press Enter to continue...{RESET}")
+                        continue
+                
+                handle_connection(config, "vpn")
+                input(f"\n  {DIM}Press Enter to continue...{RESET}")
+            
+            elif mode_choice == 2:
+                if not client_exists():
+                    print(f"\n{YELLOW}⟳{RESET} Downloading client...")
+                    if not download_client():
+                        print(f"\n{RED}✗{RESET} Failed to download client.")
+                        input(f"\n  {DIM}Press Enter to continue...{RESET}")
+                        continue
+                
+                handle_connection(config, "proxy")
+                input(f"\n  {DIM}Press Enter to continue...{RESET}")
+            
+            elif mode_choice == 3:
+                continue
+        
+        elif choice == 2:
+            print()
+            config = prompt_for_config()
+            save_config(config)
+            print(f"\n{GREEN}✓{RESET} Configuration updated!")
+            input(f"\n  {DIM}Press Enter to continue...{RESET}")
+        
+        elif choice == 3:
+            clear_screen()
+            print(f"\n{CYAN}╔═══════════════════════════════════════╗{RESET}")
+            print(f"{CYAN}║{RESET}  {GREEN}✓{RESET} Thanks for using LocalStream!     {CYAN}║{RESET}")
+            print(f"{CYAN}╚═══════════════════════════════════════╝{RESET}\n")
+            sys.exit(0)
+
+
+def main():
+    try:
+        if config_exists():
+            handle_menu()
+        else:
+            handle_first_run()
+    except KeyboardInterrupt:
+        print(f"\n\n{GREEN}✓{RESET} Goodbye!")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

localstream-1.0.0/localstream/config.py

@@ -0,0 +1,40 @@
+import json
+import os
+from pathlib import Path
+
+
+def get_config_dir() -> Path:
+    config_dir = Path.home() / ".localstream"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_config_path() -> Path:
+    return get_config_dir() / "config.json"
+
+
+def config_exists() -> bool:
+    return get_config_path().exists()
+
+
+def load_config() -> dict:
+    config_path = get_config_path()
+    if not config_path.exists():
+        return {}
+    with open(config_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def save_config(config: dict) -> None:
+    config_path = get_config_path()
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+
+def get_default_config() -> dict:
+    return {
+        "server_ip": "",
+        "server_port": 53,
+        "local_port": 5201,
+        "domain": ""
+    }

localstream-1.0.0/localstream/connection.py

@@ -0,0 +1,403 @@
+import subprocess
+import signal
+import sys
+import threading
+import ctypes
+import re
+import time
+from pathlib import Path
+
+from localstream.downloader import get_client_path, get_tun2proxy_path, client_exists, tun2proxy_exists, download_client, download_tun2proxy
+
+
+CYAN = "\033[96m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+RED = "\033[91m"
+BLUE = "\033[94m"
+MAGENTA = "\033[95m"
+WHITE = "\033[97m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+
+LOG_PATTERNS = {
+    r"INFO.*Listening on TCP port (\d+)": lambda m: f"{GREEN}●{RESET} Listening on port {WHITE}{m.group(1)}{RESET}",
+    r"INFO.*Connection ready": lambda m: f"{GREEN}●{RESET} {GREEN}Connection ready!{RESET}",
+    r"INFO.*accepted new client": lambda m: f"{BLUE}→{RESET} New client connected",
+    r"INFO.*client disconnected": lambda m: f"{BLUE}←{RESET} Client disconnected",
+    r"WARN.*certificate pinning": lambda m: f"{YELLOW}!{RESET} {DIM}Certificate pinning disabled{RESET}",
+    r"ERROR|FATAL": lambda m: f"{RED}✗{RESET} {m.group(0)}",
+    r"INFO.*bytes.*transferred": lambda m: f"{DIM}↔{RESET} {DIM}Data transferred{RESET}",
+}
+
+
+def format_log_line(line: str) -> str:
+    line = line.strip()
+    if not line:
+        return None
+    
+    for pattern, formatter in LOG_PATTERNS.items():
+        match = re.search(pattern, line, re.IGNORECASE)
+        if match:
+            return formatter(match)
+    
+    if "INFO" in line or "DEBUG" in line:
+        return None
+    
+    return f"{DIM}│{RESET} {line}"
+
+
+def is_admin() -> bool:
+    try:
+        return ctypes.windll.shell32.IsUserAnAdmin()
+    except:
+        return False
+
+
+def run_as_admin():
+    if sys.platform != "win32":
+        return False
+    
+    try:
+        ctypes.windll.shell32.ShellExecuteW(
+            None, "runas", sys.executable, " ".join(sys.argv), None, 1
+        )
+        return True
+    except:
+        return False
+
+
+class ConnectionManager:
+    def __init__(self):
+        self.slipstream_process = None
+        self.tun2proxy_process = None
+        self.restart_requested = False
+        self.user_disconnected = False
+        self.stop_listener = False
+        self._original_sigint = None
+        self._listener_thread = None
+        self._monitor_thread = None
+    
+    def _setup_signal_handlers(self):
+        self._original_sigint = signal.signal(signal.SIGINT, self._sigint_handler)
+    
+    def _restore_signal_handlers(self):
+        if self._original_sigint:
+            signal.signal(signal.SIGINT, self._original_sigint)
+    
+    def _sigint_handler(self, signum, frame):
+        print(f"\n\n{YELLOW}⟳{RESET} Disconnecting...")
+        self.user_disconnected = True
+        self.disconnect()
+        raise KeyboardInterrupt()
+    
+    def _keyboard_listener(self):
+        try:
+            import msvcrt
+            while not self.stop_listener:
+                if msvcrt.kbhit():
+                    key = msvcrt.getch()
+                    if key == b'\x04':
+                        self.restart_requested = True
+                        self.disconnect()
+                        return
+                threading.Event().wait(0.1)
+        except:
+            pass
+    
+    def _start_keyboard_listener(self):
+        self.stop_listener = False
+        self._listener_thread = threading.Thread(target=self._keyboard_listener, daemon=True)
+        self._listener_thread.start()
+    
+    def _stop_keyboard_listener(self):
+        self.stop_listener = True
+        if self._listener_thread and self._listener_thread.is_alive():
+            self._listener_thread.join(timeout=0.5)
+    
+    def connect_proxy(self, config: dict) -> str:
+        if not client_exists():
+            if not download_client():
+                print(f"{RED}✗{RESET} Cannot connect: slipstream-client not available")
+                return "error"
+        
+        client_path = get_client_path()
+        server_ip = config.get("server_ip", "")
+        server_port = config.get("server_port", 53)
+        local_port = config.get("local_port", 5201)
+        domain = config.get("domain", "")
+        
+        if not server_ip or not domain:
+            print(f"{RED}✗{RESET} Invalid configuration: server_ip and domain are required")
+            return "error"
+        
+        resolver = f"{server_ip}:{server_port}"
+        
+        cmd = [
+            str(client_path),
+            "--resolver", resolver,
+            "--domain", domain,
+            "--tcp-listen-port", str(local_port)
+        ]
+        
+        self._setup_signal_handlers()
+        self.restart_requested = False
+        self.user_disconnected = False
+        reconnect_count = 0
+        
+        try:
+            while True:
+                self.slipstream_process = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    bufsize=1,
+                    creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+                )
+                
+                self._start_keyboard_listener()
+                
+                if reconnect_count == 0:
+                    print(f"\n{CYAN}┌{'─' * 50}┐{RESET}")
+                    print(f"{CYAN}│{RESET}  {GREEN}●{RESET} {BOLD}PROXY Mode - Connection Status{RESET}{' ' * 16}{CYAN}│{RESET}")
+                    print(f"{CYAN}└{'─' * 50}┘{RESET}\n")
+                else:
+                    print(f"\n  {GREEN}●{RESET} Reconnected! (attempt #{reconnect_count + 1})\n")
+                
+                for line in self.slipstream_process.stdout:
+                    if self.restart_requested or self.user_disconnected:
+                        break
+                    formatted = format_log_line(line)
+                    if formatted:
+                        print(f"  {formatted}")
+                
+                self.slipstream_process.wait()
+                self._stop_keyboard_listener()
+                
+                if self.restart_requested:
+                    return "restart"
+                
+                if self.user_disconnected:
+                    return "done"
+                
+                return_code = self.slipstream_process.returncode
+                if return_code != 0:
+                    reconnect_count += 1
+                    print(f"\n  {YELLOW}!{RESET} Connection dropped (code: {return_code})")
+                    print(f"  {YELLOW}⟳{RESET} Auto-reconnecting in 3 seconds...")
+                    time.sleep(3)
+                    continue
+                
+                return "done"
+            
+        except KeyboardInterrupt:
+            self._stop_keyboard_listener()
+            return "done"
+        except FileNotFoundError:
+            print(f"{RED}✗{RESET} Client not found: {client_path}")
+            return "error"
+        except Exception as e:
+            print(f"{RED}✗{RESET} Connection error: {e}")
+            return "error"
+        finally:
+            self._restore_signal_handlers()
+            self._stop_keyboard_listener()
+            self.disconnect()
+    
+    def _monitor_slipstream(self, cmd):
+        reconnect_count = 0
+        while not self.user_disconnected and not self.restart_requested:
+            if self.slipstream_process and self.slipstream_process.poll() is not None:
+                return_code = self.slipstream_process.returncode
+                if return_code != 0 and not self.user_disconnected:
+                    reconnect_count += 1
+                    print(f"\n  {YELLOW}!{RESET} Slipstream dropped (code: {return_code})")
+                    print(f"  {YELLOW}⟳{RESET} Auto-reconnecting...")
+                    time.sleep(2)
+                    
+                    try:
+                        self.slipstream_process = subprocess.Popen(
+                            cmd,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.STDOUT,
+                            text=True,
+                            bufsize=1,
+                            creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+                        )
+                        time.sleep(2)
+                        if self.slipstream_process.poll() is None:
+                            print(f"  {GREEN}●{RESET} Slipstream reconnected! (attempt #{reconnect_count + 1})")
+                    except:
+                        pass
+            time.sleep(1)
+    
+    def connect_vpn(self, config: dict) -> str:
+        if not is_admin():
+            print(f"\n{RED}✗{RESET} VPN Mode requires Administrator privileges!")
+            print(f"{YELLOW}!{RESET} Please run LocalStream as Administrator")
+            return "error"
+        
+        if not client_exists():
+            if not download_client():
+                print(f"{RED}✗{RESET} Cannot connect: slipstream-client not available")
+                return "error"
+        
+        if not tun2proxy_exists():
+            if not download_tun2proxy():
+                print(f"{RED}✗{RESET} Cannot connect: tun2proxy not available")
+                return "error"
+        
+        client_path = get_client_path()
+        tun2proxy_path = get_tun2proxy_path()
+        server_ip = config.get("server_ip", "")
+        server_port = config.get("server_port", 53)
+        local_port = config.get("local_port", 5201)
+        domain = config.get("domain", "")
+        
+        if not server_ip or not domain:
+            print(f"{RED}✗{RESET} Invalid configuration: server_ip and domain are required")
+            return "error"
+        
+        resolver = f"{server_ip}:{server_port}"
+        
+        slipstream_cmd = [
+            str(client_path),
+            "--resolver", resolver,
+            "--domain", domain,
+            "--tcp-listen-port", str(local_port)
+        ]
+        
+        tun2proxy_cmd = [
+            str(tun2proxy_path),
+            "--setup",
+            "--proxy", f"socks5://127.0.0.1:{local_port}",
+            "--bypass", server_ip,
+            "--dns", "virtual"
+        ]
+        
+        self._setup_signal_handlers()
+        self.restart_requested = False
+        self.user_disconnected = False
+        
+        try:
+            print(f"\n{CYAN}┌{'─' * 50}┐{RESET}")
+            print(f"{CYAN}│{RESET}  {GREEN}●{RESET} {BOLD}VPN Mode - Starting Tunnel{RESET}{' ' * 21}{CYAN}│{RESET}")
+            print(f"{CYAN}└{'─' * 50}┘{RESET}\n")
+            
+            print(f"  {YELLOW}⟳{RESET} Starting slipstream-client...")
+            self.slipstream_process = subprocess.Popen(
+                slipstream_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+            )
+            
+            time.sleep(2)
+            
+            if self.slipstream_process.poll() is not None:
+                print(f"  {RED}✗{RESET} Slipstream failed to start")
+                return "error"
+            
+            print(f"  {GREEN}✓{RESET} Slipstream-client running on port {local_port}")
+            
+            print(f"  {YELLOW}⟳{RESET} Starting tun2proxy (VPN tunnel)...")
+            self.tun2proxy_process = subprocess.Popen(
+                tun2proxy_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1
+            )
+            
+            time.sleep(2)
+            
+            if self.tun2proxy_process.poll() is not None:
+                print(f"  {RED}✗{RESET} tun2proxy failed to start")
+                self.disconnect()
+                return "error"
+            
+            print(f"  {GREEN}✓{RESET} VPN tunnel established!")
+            print(f"\n{GREEN}{'═' * 52}{RESET}")
+            print(f"{GREEN}  ✓ All traffic is now routed through the VPN!{RESET}")
+            print(f"{GREEN}{'═' * 52}{RESET}")
+            print(f"\n  {DIM}Press Ctrl+C to disconnect{RESET}\n")
+            
+            self._monitor_thread = threading.Thread(
+                target=self._monitor_slipstream, 
+                args=(slipstream_cmd,), 
+                daemon=True
+            )
+            self._monitor_thread.start()
+            
+            self._start_keyboard_listener()
+            
+            ignore_patterns = [
+                "brokenpipe",
+                "tcp connection closed",
+                "connection closed",
+                "connectionnotallowed",
+                "ending #",
+                "info  tun2proxy",
+            ]
+            
+            for line in self.tun2proxy_process.stdout:
+                if self.restart_requested:
+                    break
+                line = line.strip()
+                if not line:
+                    continue
+                
+                line_lower = line.lower()
+                if any(pattern in line_lower for pattern in ignore_patterns):
+                    continue
+                
+                if "error" in line_lower or "fatal" in line_lower:
+                    print(f"  {RED}✗{RESET} {line}")
+            
+            self.tun2proxy_process.wait()
+            self._stop_keyboard_listener()
+            
+            if self.restart_requested:
+                return "restart"
+            
+            return "done"
+            
+        except KeyboardInterrupt:
+            self._stop_keyboard_listener()
+            return "done"
+        except FileNotFoundError as e:
+            print(f"{RED}✗{RESET} Binary not found: {e}")
+            return "error"
+        except Exception as e:
+            print(f"{RED}✗{RESET} Connection error: {e}")
+            return "error"
+        finally:
+            self._restore_signal_handlers()
+            self._stop_keyboard_listener()
+            self.disconnect()
+    
+    def disconnect(self):
+        self.user_disconnected = True
+        
+        if self.tun2proxy_process and self.tun2proxy_process.poll() is None:
+            self.tun2proxy_process.terminate()
+            try:
+                self.tun2proxy_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.tun2proxy_process.kill()
+            print(f"{GREEN}✓{RESET} VPN tunnel closed")
+        self.tun2proxy_process = None
+        
+        if self.slipstream_process and self.slipstream_process.poll() is None:
+            self.slipstream_process.terminate()
+            try:
+                self.slipstream_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.slipstream_process.kill()
+            print(f"{GREEN}✓{RESET} Slipstream disconnected")
+        self.slipstream_process = None

localstream-1.0.0/localstream/downloader.py

@@ -0,0 +1,197 @@
+import os
+import sys
+import requests
+import zipfile
+import tempfile
+from pathlib import Path
+
+from localstream.config import get_config_dir
+
+
+CYAN = "\033[96m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+RED = "\033[91m"
+DIM = "\033[2m"
+RESET = "\033[0m"
+
+
+SLIPSTREAM_URL = "https://github.com/AliRezaBeigy/slipstream-rust-deploy/releases/latest/download/slipstream-client-windows-amd64.exe"
+TUN2PROXY_URL = "https://github.com/tun2proxy/tun2proxy/releases/download/v0.7.19/tun2proxy-x86_64-pc-windows-msvc.zip"
+WINTUN_URL = "https://www.wintun.net/builds/wintun-0.14.1.zip"
+
+
+def get_bin_dir() -> Path:
+    bin_dir = get_config_dir() / "bin"
+    bin_dir.mkdir(parents=True, exist_ok=True)
+    return bin_dir
+
+
+def get_client_path() -> Path:
+    return get_bin_dir() / "slipstream-client.exe"
+
+
+def get_tun2proxy_path() -> Path:
+    return get_bin_dir() / "tun2proxy.exe"
+
+
+def get_wintun_path() -> Path:
+    return get_bin_dir() / "wintun.dll"
+
+
+def client_exists() -> bool:
+    return get_client_path().exists()
+
+
+def tun2proxy_exists() -> bool:
+    return get_tun2proxy_path().exists() and get_wintun_path().exists()
+
+
+def download_file(url: str, dest_path: Path, name: str) -> bool:
+    print(f"\n{CYAN}╔═══════════════════════════════════════════════════════╗{RESET}")
+    print(f"{CYAN}║{RESET}  {YELLOW}⟳{RESET} Downloading {name}...{' ' * (37 - len(name))}{CYAN}║{RESET}")
+    print(f"{CYAN}╚═══════════════════════════════════════════════════════╝{RESET}")
+    print(f"\n{DIM}  URL: {url[:50]}...{RESET}")
+    print(f"{DIM}  Destination: {dest_path}{RESET}\n")
+    
+    try:
+        response = requests.get(url, stream=True, timeout=120)
+        response.raise_for_status()
+        
+        total_size = int(response.headers.get("content-length", 0))
+        downloaded = 0
+        
+        with open(dest_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    if total_size > 0:
+                        percent = (downloaded / total_size) * 100
+                        bar_length = 40
+                        filled = int(bar_length * downloaded / total_size)
+                        bar = f"{GREEN}{'█' * filled}{DIM}{'░' * (bar_length - filled)}{RESET}"
+                        size_mb = downloaded / (1024 * 1024)
+                        total_mb = total_size / (1024 * 1024)
+                        print(f"\r  {bar} {percent:5.1f}% ({size_mb:.1f}/{total_mb:.1f} MB)", end="", flush=True)
+        
+        print(f"\n\n{GREEN}✓{RESET} Download complete!")
+        return True
+        
+    except requests.RequestException as e:
+        print(f"\n\n{RED}✗{RESET} Download failed: {e}")
+        if dest_path.exists():
+            dest_path.unlink()
+        return False
+
+
+def download_client(force: bool = False) -> bool:
+    client_path = get_client_path()
+    
+    if client_path.exists() and not force:
+        return True
+    
+    return download_file(SLIPSTREAM_URL, client_path, "slipstream-client")
+
+
+def download_tun2proxy(force: bool = False) -> bool:
+    tun2proxy_path = get_tun2proxy_path()
+    wintun_path = get_wintun_path()
+    bin_dir = get_bin_dir()
+    
+    if tun2proxy_path.exists() and wintun_path.exists() and not force:
+        return True
+    
+    if not tun2proxy_path.exists() or force:
+        print(f"\n{CYAN}╔═══════════════════════════════════════════════════════╗{RESET}")
+        print(f"{CYAN}║{RESET}  {YELLOW}⟳{RESET} Downloading tun2proxy...                            {CYAN}║{RESET}")
+        print(f"{CYAN}╚═══════════════════════════════════════════════════════╝{RESET}")
+        print(f"\n{DIM}  URL: {TUN2PROXY_URL[:50]}...{RESET}\n")
+        
+        try:
+            with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp:
+                tmp_path = Path(tmp.name)
+            
+            response = requests.get(TUN2PROXY_URL, stream=True, timeout=120)
+            response.raise_for_status()
+            
+            total_size = int(response.headers.get("content-length", 0))
+            downloaded = 0
+            
+            with open(tmp_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        if total_size > 0:
+                            percent = (downloaded / total_size) * 100
+                            bar_length = 40
+                            filled = int(bar_length * downloaded / total_size)
+                            bar = f"{GREEN}{'█' * filled}{DIM}{'░' * (bar_length - filled)}{RESET}"
+                            size_mb = downloaded / (1024 * 1024)
+                            total_mb = total_size / (1024 * 1024)
+                            print(f"\r  {bar} {percent:5.1f}% ({size_mb:.1f}/{total_mb:.1f} MB)", end="", flush=True)
+            
+            print(f"\n\n{YELLOW}⟳{RESET} Extracting tun2proxy...")
+            
+            with zipfile.ZipFile(tmp_path, 'r') as zip_ref:
+                for file_info in zip_ref.namelist():
+                    if file_info.endswith("tun2proxy-bin.exe") or file_info.endswith("tun2proxy.exe"):
+                        with zip_ref.open(file_info) as src:
+                            with open(tun2proxy_path, "wb") as dst:
+                                dst.write(src.read())
+                        break
+                    elif file_info.endswith(".exe") and "tun2proxy" in file_info:
+                        with zip_ref.open(file_info) as src:
+                            with open(tun2proxy_path, "wb") as dst:
+                                dst.write(src.read())
+                        break
+            
+            tmp_path.unlink()
+            
+            if not tun2proxy_path.exists():
+                print(f"{RED}✗{RESET} Failed to extract tun2proxy.exe from archive")
+                return False
+            
+            print(f"{GREEN}✓{RESET} tun2proxy extracted!")
+            
+        except Exception as e:
+            print(f"\n{RED}✗{RESET} Failed to download tun2proxy: {e}")
+            return False
+    
+    if not wintun_path.exists() or force:
+        print(f"\n{YELLOW}⟳{RESET} Downloading wintun driver...")
+        
+        try:
+            with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as tmp:
+                tmp_path = Path(tmp.name)
+            
+            response = requests.get(WINTUN_URL, timeout=120)
+            response.raise_for_status()
+            
+            with open(tmp_path, "wb") as f:
+                f.write(response.content)
+            
+            print(f"{YELLOW}⟳{RESET} Extracting wintun.dll...")
+            
+            with zipfile.ZipFile(tmp_path, 'r') as zip_ref:
+                for file_info in zip_ref.namelist():
+                    if file_info.endswith("amd64/wintun.dll"):
+                        with zip_ref.open(file_info) as src:
+                            with open(wintun_path, "wb") as dst:
+                                dst.write(src.read())
+                        break
+            
+            tmp_path.unlink()
+            
+            if not wintun_path.exists():
+                print(f"{RED}✗{RESET} Failed to extract wintun.dll from archive")
+                return False
+            
+            print(f"{GREEN}✓{RESET} Wintun driver extracted!")
+            
+        except Exception as e:
+            print(f"{RED}✗{RESET} Failed to download wintun: {e}")
+            return False
+    
+    return True

localstream-1.0.0/localstream.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: localstream
+Version: 1.0.0
+Summary: Python CLI client for slipstream-rust DNS tunnel
+Author: LocalStream Team
+License: MIT
+Keywords: dns,tunnel,vpn,slipstream,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: Proxy Servers
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: colorama>=0.4.6
+
+# LocalStream
+
+A Python command-line client for [slipstream-rust](https://github.com/Mygod/slipstream-rust) DNS tunnel.
+
+## Features
+
+- **VPN Mode**: System-wide traffic tunneling (requires Admin)
+- **PROXY Mode**: SOCKS5 proxy on local port
+- Auto-reconnect on connection drops
+- Easy pip installation
+- Colorful CLI interface
+
+## Requirements
+
+- Python 3.13+
+- Windows OS
+- Administrator privileges (for VPN Mode)
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+LocalStream          # Normal user (PROXY mode only)
+# Run as Administrator for VPN mode
+```
+
+### Menu Options
+
+```
+[1] Connect to server
+    ├── [1] VPN Mode   (system-wide, requires Admin)
+    ├── [2] PROXY Mode (SOCKS5 only)
+    └── [3] Back
+[2] Edit configuration
+[3] Exit
+```
+
+### Keyboard Shortcuts
+
+- **Ctrl+C**: Disconnect and exit
+- **Ctrl+D**: Restart connection
+
+## Configuration
+
+Config stored in `~/.localstream/config.json`:
+
+```json
+{
+  "server_ip": "203.0.113.2",
+  "server_port": 53,
+  "local_port": 5201,
+  "domain": "s.example.com"
+}
+```
+
+## Downloaded Binaries
+
+Stored in `~/.localstream/bin/`:
+- `slipstream-client.exe` - DNS tunnel client
+- `tun2proxy.exe` - TUN adapter for VPN mode
+- `wintun.dll` - Windows TUN driver
+
+## License
+
+MIT

localstream-1.0.0/localstream.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+localstream/__init__.py
+localstream/__main__.py
+localstream/cli.py
+localstream/config.py
+localstream/connection.py
+localstream/downloader.py
+localstream.egg-info/PKG-INFO
+localstream.egg-info/SOURCES.txt
+localstream.egg-info/dependency_links.txt
+localstream.egg-info/entry_points.txt
+localstream.egg-info/requires.txt
+localstream.egg-info/top_level.txt

localstream-1.0.0/localstream.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

localstream-1.0.0/localstream.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+LocalStream = localstream.cli:main

localstream-1.0.0/localstream.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.31.0
+colorama>=0.4.6

localstream-1.0.0/localstream.egg-info/top_level.txt

@@ -0,0 +1 @@
+localstream

localstream-1.0.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "localstream"
+version = "1.0.0"
+description = "Python CLI client for slipstream-rust DNS tunnel"
+readme = "README.md"
+requires-python = ">=3.13"
+license = {text = "MIT"}
+authors = [
+    {name = "LocalStream Team"}
+]
+keywords = ["dns", "tunnel", "vpn", "slipstream", "cli"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: Proxy Servers",
+]
+dependencies = [
+    "requests>=2.31.0",
+    "colorama>=0.4.6",
+]
+
+[project.scripts]
+LocalStream = "localstream.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["localstream*"]

localstream-1.0.0/setup.cfg

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