frp-tunnel 1.0.4__py3-none-any.whl

frp_tunnel/__init__.py

@@ -0,0 +1,9 @@
+"""FRP Tunnel Package"""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"
+
+from .cli import main
+
+__all__ = ['main']

frp_tunnel/_version.py

@@ -0,0 +1 @@
+version = "1.0.4"

frp_tunnel/cli.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+FRP Tunnel CLI - Easy SSH tunneling with FRP
+"""
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from .core.installer import install_binaries
+from .core.tunnel import TunnelManager
+from .core.platform import detect_platform, is_colab
+from .core.config import ConfigManager
+
+console = Console()
+tunnel_manager = TunnelManager()
+config_manager = ConfigManager()
+
+@click.group()
+@click.version_option()
+def cli():
+    """🚀 FRP Tunnel - Easy SSH tunneling with FRP"""
+    pass
+
+@cli.command()
+@click.option('--mode', type=click.Choice(['server', 'client', 'colab', 'auto']), default='auto', help='Setup mode')
+@click.option('--server', help='Server address (for client mode)')
+@click.option('--token', help='Authentication token')
+@click.option('--port', default=6001, help='Remote port')
+@click.option('--user', default='colab', help='SSH username')
+def setup(mode, server, token, port, user):
+    """Interactive setup wizard"""
+    console.print(Panel.fit("🚀 FRP Tunnel Setup", style="bold blue"))
+    
+    # Auto-detect mode if not specified
+    if mode == 'auto':
+        if is_colab():
+            mode = 'colab'
+            console.print("🔬 Detected Google Colab environment")
+        else:
+            mode = click.prompt('Setup mode', type=click.Choice(['server', 'client']))
+    
+    if mode == 'server':
+        setup_server()
+    elif mode in ['client', 'colab']:
+        setup_client(mode, server, token, port, user)
+
+def setup_server():
+    """Setup FRP server"""
+    console.print("🖥️  Setting up FRP server...")
+    
+    port = click.prompt('Server port', default=7000, type=int)
+    token = click.prompt('Authentication token (empty to generate)', default='', show_default=False)
+    
+    if not token:
+        import secrets
+        token = f"frp_{secrets.token_hex(16)}"
+        console.print(f"🔑 Generated token: [bold yellow]{token}[/bold yellow]")
+    
+    # Install server binary
+    with console.status("📦 Installing FRP server..."):
+        install_binaries('server')
+    
+    # Create configuration
+    config = {
+        'bind_port': port,
+        'token': token
+    }
+    config_manager.create_server_config(config)
+    
+    # Start server
+    if click.confirm('Start server now?', default=True):
+        tunnel_manager.start_server(config)
+        console.print("✅ Server started successfully!")
+        console.print(f"🔑 Share this token with clients: [bold]{token}[/bold]")
+
+def setup_client(mode, server, token, port, user):
+    """Setup FRP client"""
+    console.print(f"📱 Setting up FRP client ({mode})...")
+    
+    # Get configuration
+    if not server:
+        server = click.prompt('Server address')
+    if not token:
+        token = click.prompt('Authentication token')
+    
+    # Install client binary
+    with console.status("📦 Installing FRP client..."):
+        install_binaries('client')
+    
+    # Create configuration
+    config = {
+        'server_addr': server,
+        'server_port': 7000,
+        'token': token,
+        'remote_port': port,
+        'username': user
+    }
+    config_manager.create_client_config(config)
+    
+    # Setup SSH for Colab
+    if mode == 'colab':
+        with console.status("🔧 Setting up SSH..."):
+            tunnel_manager.setup_colab_ssh(user)
+    
+    # Start client
+    tunnel_manager.start_client(config)
+    console.print("✅ Client connected successfully!")
+    console.print(f"🔗 SSH command: [bold]ssh -p {port} {user}@{server}[/bold]")
+
+@cli.command()
+@click.option('--server', required=True, help='Server address')
+@click.option('--token', required=True, help='Authentication token')
+@click.option('--port', default=6001, help='Remote port')
+@click.option('--user', default='colab', help='SSH username')
+def colab(server, token, port, user):
+    """Quick setup for Google Colab"""
+    console.print("🔬 Setting up Google Colab tunnel...")
+    setup_client('colab', server, token, port, user)
+
+@cli.command()
+def status():
+    """Show tunnel status"""
+    console.print("📊 Tunnel Status")
+    status_info = tunnel_manager.get_status()
+    
+    if status_info['server_running']:
+        console.print("🖥️  Server: [green]Running[/green]")
+    else:
+        console.print("🖥️  Server: [red]Stopped[/red]")
+    
+    if status_info['client_running']:
+        console.print("📱 Client: [green]Connected[/green]")
+    else:
+        console.print("📱 Client: [red]Disconnected[/red]")
+
+@cli.command()
+def stop():
+    """Stop all tunnels"""
+    console.print("🛑 Stopping tunnels...")
+    tunnel_manager.stop_all()
+    console.print("✅ All tunnels stopped")
+
+@cli.command()
+def logs():
+    """View tunnel logs"""
+    console.print("📝 Recent logs:")
+    logs = tunnel_manager.get_logs()
+    for log_line in logs:
+        console.print(log_line)
+
+@cli.command()
+def install():
+    """Install/update FRP binaries"""
+    console.print("📦 Installing FRP binaries...")
+    with console.status("Downloading..."):
+        install_binaries()
+    console.print("✅ Installation complete")
+
+@cli.command()
+def clean():
+    """Clean cache and temporary files"""
+    console.print("🧹 Cleaning cache...")
+    tunnel_manager.clean_cache()
+    console.print("✅ Cache cleaned")
+
+def main():
+    """Entry point for the CLI"""
+    cli()
+
+if __name__ == '__main__':
+    main()

frp_tunnel/core/__init__.py

@@ -0,0 +1,16 @@
+"""Core module initialization"""
+
+from .platform import detect_platform, is_colab
+from .installer import install_binaries, get_binary_path, is_installed
+from .config import ConfigManager
+from .tunnel import TunnelManager
+
+__all__ = [
+    'detect_platform',
+    'is_colab', 
+    'install_binaries',
+    'get_binary_path',
+    'is_installed',
+    'ConfigManager',
+    'TunnelManager'
+]

frp_tunnel/core/config.py

@@ -0,0 +1,98 @@
+"""Configuration management"""
+
+import os
+import secrets
+from pathlib import Path
+from typing import Dict, Any
+import configparser
+
+class ConfigManager:
+    def __init__(self):
+        self.config_dir = Path.home() / '.frp-tunnel'
+        self.config_dir.mkdir(exist_ok=True)
+        
+        self.server_config_path = self.config_dir / 'frps.ini'
+        self.client_config_path = self.config_dir / 'frpc.ini'
+    
+    def create_server_config(self, config: Dict[str, Any]) -> Path:
+        """Create server configuration file"""
+        config_content = f"""[common]
+bind_port = {config.get('bind_port', 7000)}
+token = {config.get('token', self._generate_token())}
+
+# Dashboard (optional)
+dashboard_port = 7500
+dashboard_user = admin
+dashboard_pwd = admin
+
+# Logging
+log_file = {self.config_dir}/frps.log
+log_level = info
+log_max_days = 3
+
+# Security
+authentication_method = token
+heartbeat_timeout = 90
+"""
+        
+        with open(self.server_config_path, 'w') as f:
+            f.write(config_content)
+        
+        return self.server_config_path
+    
+    def create_client_config(self, config: Dict[str, Any]) -> Path:
+        """Create client configuration file"""
+        config_content = f"""[common]
+server_addr = {config['server_addr']}
+server_port = {config.get('server_port', 7000)}
+token = {config['token']}
+
+# Logging
+log_file = {self.config_dir}/frpc.log
+log_level = info
+
+[ssh_{config.get('username', 'colab')}]
+type = tcp
+local_ip = 127.0.0.1
+local_port = 22
+remote_port = {config.get('remote_port', 6001)}
+"""
+        
+        with open(self.client_config_path, 'w') as f:
+            f.write(config_content)
+        
+        return self.client_config_path
+    
+    def get_server_config(self) -> Dict[str, Any]:
+        """Read server configuration"""
+        if not self.server_config_path.exists():
+            return {}
+        
+        config = configparser.ConfigParser()
+        config.read(self.server_config_path)
+        
+        if 'common' not in config:
+            return {}
+        
+        return dict(config['common'])
+    
+    def get_client_config(self) -> Dict[str, Any]:
+        """Read client configuration"""
+        if not self.client_config_path.exists():
+            return {}
+        
+        config = configparser.ConfigParser()
+        config.read(self.client_config_path)
+        
+        if 'common' not in config:
+            return {}
+        
+        return dict(config['common'])
+    
+    def _generate_token(self) -> str:
+        """Generate a secure token"""
+        return f"frp_{secrets.token_hex(16)}"
+    
+    def get_log_path(self, component: str) -> Path:
+        """Get log file path"""
+        return self.config_dir / f"frp{component[0]}.log"

frp_tunnel/core/installer.py

@@ -0,0 +1,118 @@
+"""Binary installer for FRP"""
+
+import os
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+from .platform import get_frp_binary_url, get_binary_names, detect_platform
+
+class BinaryInstaller:
+    def __init__(self):
+        self.platform_info = detect_platform()
+        self.binary_names = get_binary_names()
+        self.install_dir = Path.home() / '.frp-tunnel' / 'bin'
+        self.install_dir.mkdir(parents=True, exist_ok=True)
+    
+    def install_binaries(self, component: Optional[str] = None) -> bool:
+        """Install FRP binaries
+        
+        Args:
+            component: 'server', 'client', or None for both
+        """
+        try:
+            # Download and extract
+            binary_path = self._download_and_extract()
+            
+            # Copy required binaries
+            if component == 'server' or component is None:
+                self._copy_binary(binary_path, 'server')
+            
+            if component == 'client' or component is None:
+                self._copy_binary(binary_path, 'client')
+            
+            # Make binaries executable
+            self._make_executable()
+            
+            return True
+            
+        except Exception as e:
+            print(f"Error installing binaries: {e}")
+            return False
+    
+    def _download_and_extract(self) -> Path:
+        """Download and extract FRP archive"""
+        url = get_frp_binary_url()
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            archive_path = temp_path / 'frp.tar.gz'
+            
+            # Download
+            urllib.request.urlretrieve(url, archive_path)
+            
+            # Extract
+            with tarfile.open(archive_path, 'r:gz') as tar:
+                tar.extractall(temp_path)
+            
+            # Find extracted directory
+            extracted_dirs = [d for d in temp_path.iterdir() if d.is_dir()]
+            if not extracted_dirs:
+                raise Exception("No directory found in archive")
+            
+            binary_path = extracted_dirs[0]
+            
+            # Copy to permanent location
+            import shutil
+            permanent_path = self.install_dir / 'extracted'
+            if permanent_path.exists():
+                shutil.rmtree(permanent_path)
+            shutil.copytree(binary_path, permanent_path)
+            
+            return permanent_path
+    
+    def _copy_binary(self, source_dir: Path, component: str):
+        """Copy binary to install directory"""
+        binary_name = self.binary_names[component]
+        source_file = source_dir / binary_name
+        dest_file = self.install_dir / binary_name
+        
+        if not source_file.exists():
+            raise Exception(f"Binary {binary_name} not found in archive")
+        
+        import shutil
+        shutil.copy2(source_file, dest_file)
+    
+    def _make_executable(self):
+        """Make binaries executable on Unix systems"""
+        if self.platform_info['os'] != 'windows':
+            for binary_name in self.binary_names.values():
+                binary_path = self.install_dir / binary_name
+                if binary_path.exists():
+                    os.chmod(binary_path, 0o755)
+    
+    def get_binary_path(self, component: str) -> Path:
+        """Get path to installed binary"""
+        binary_name = self.binary_names[component]
+        return self.install_dir / binary_name
+    
+    def is_installed(self, component: str) -> bool:
+        """Check if binary is installed"""
+        return self.get_binary_path(component).exists()
+
+# Global installer instance
+_installer = BinaryInstaller()
+
+def install_binaries(component: Optional[str] = None) -> bool:
+    """Install FRP binaries"""
+    return _installer.install_binaries(component)
+
+def get_binary_path(component: str) -> Path:
+    """Get path to binary"""
+    return _installer.get_binary_path(component)
+
+def is_installed(component: str) -> bool:
+    """Check if binary is installed"""
+    return _installer.is_installed(component)

frp_tunnel/core/platform.py

@@ -0,0 +1,92 @@
+"""Platform detection and utilities"""
+
+import os
+import platform
+import subprocess
+from typing import Dict, List
+
+def detect_platform() -> Dict[str, str]:
+    """Detect current platform and architecture"""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    
+    # Normalize architecture names
+    arch_map = {
+        'x86_64': 'amd64',
+        'amd64': 'amd64',
+        'aarch64': 'arm64',
+        'arm64': 'arm64',
+        'armv7l': 'arm',
+    }
+    
+    arch = arch_map.get(machine, machine)
+    
+    return {
+        'os': system,
+        'arch': arch,
+        'platform': f"{system}-{arch}"
+    }
+
+def is_colab() -> bool:
+    """Check if running in Google Colab"""
+    return 'COLAB_GPU' in os.environ or os.path.exists('/content')
+
+def is_docker() -> bool:
+    """Check if running in Docker"""
+    return os.path.exists('/.dockerenv')
+
+def check_requirements() -> Dict[str, bool]:
+    """Check if required tools are available"""
+    requirements = {
+        'ssh': _command_exists('ssh'),
+        'wget': _command_exists('wget') or _command_exists('curl'),
+        'tar': _command_exists('tar'),
+    }
+    
+    # Additional checks for different platforms
+    if platform.system().lower() == 'linux':
+        requirements['systemctl'] = _command_exists('systemctl')
+    
+    return requirements
+
+def _command_exists(command: str) -> bool:
+    """Check if a command exists in PATH"""
+    try:
+        subprocess.run(['which', command], 
+                      capture_output=True, 
+                      check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def get_frp_binary_url(version: str = "0.52.3") -> str:
+    """Get FRP binary download URL for current platform"""
+    platform_info = detect_platform()
+    
+    # Map platform names to FRP naming convention
+    os_map = {
+        'linux': 'linux',
+        'darwin': 'darwin',
+        'windows': 'windows'
+    }
+    
+    os_name = os_map.get(platform_info['os'], platform_info['os'])
+    arch = platform_info['arch']
+    
+    filename = f"frp_{version}_{os_name}_{arch}.tar.gz"
+    url = f"https://github.com/fatedier/frp/releases/download/v{version}/{filename}"
+    
+    return url
+
+def get_binary_names() -> Dict[str, str]:
+    """Get binary names for current platform"""
+    if platform.system().lower() == 'windows':
+        return {
+            'server': 'frps.exe',
+            'client': 'frpc.exe'
+        }
+    else:
+        return {
+            'server': 'frps',
+            'client': 'frpc'
+        }

frp_tunnel/core/tunnel.py

@@ -0,0 +1,208 @@
+"""Tunnel management"""
+
+import os
+import subprocess
+import signal
+import time
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .installer import get_binary_path, is_installed, install_binaries
+from .config import ConfigManager
+from .platform import is_colab
+
+class TunnelManager:
+    def __init__(self):
+        self.config_manager = ConfigManager()
+        self.pid_dir = Path.home() / '.frp-tunnel' / 'pids'
+        self.pid_dir.mkdir(parents=True, exist_ok=True)
+    
+    def start_server(self, config: Dict) -> bool:
+        """Start FRP server"""
+        if not is_installed('server'):
+            install_binaries('server')
+        
+        binary_path = get_binary_path('server')
+        config_path = self.config_manager.create_server_config(config)
+        
+        try:
+            # Start server process
+            process = subprocess.Popen([
+                str(binary_path),
+                '-c', str(config_path)
+            ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            # Save PID
+            pid_file = self.pid_dir / 'frps.pid'
+            with open(pid_file, 'w') as f:
+                f.write(str(process.pid))
+            
+            # Wait a moment to check if it started successfully
+            time.sleep(2)
+            if process.poll() is None:
+                return True
+            else:
+                return False
+                
+        except Exception as e:
+            print(f"Error starting server: {e}")
+            return False
+    
+    def start_client(self, config: Dict) -> bool:
+        """Start FRP client"""
+        if not is_installed('client'):
+            install_binaries('client')
+        
+        binary_path = get_binary_path('client')
+        config_path = self.config_manager.create_client_config(config)
+        
+        try:
+            # Start client process
+            process = subprocess.Popen([
+                str(binary_path),
+                '-c', str(config_path)
+            ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            # Save PID
+            pid_file = self.pid_dir / 'frpc.pid'
+            with open(pid_file, 'w') as f:
+                f.write(str(process.pid))
+            
+            # Wait a moment to check if it started successfully
+            time.sleep(2)
+            if process.poll() is None:
+                return True
+            else:
+                return False
+                
+        except Exception as e:
+            print(f"Error starting client: {e}")
+            return False
+    
+    def setup_colab_ssh(self, username: str = 'colab'):
+        """Setup SSH for Google Colab environment"""
+        try:
+            # Generate SSH key if not exists
+            subprocess.run([
+                'bash', '-c',
+                'test -f ~/.ssh/id_rsa || ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""'
+            ], check=True)
+            
+            # Create user if not exists
+            subprocess.run([
+                'bash', '-c',
+                f'id {username} || sudo useradd -m -s /bin/bash {username}'
+            ], check=False)  # Don't fail if user exists
+            
+            # Setup SSH key
+            subprocess.run([
+                'bash', '-c',
+                f'''
+                sudo mkdir -p /home/{username}/.ssh
+                sudo cp ~/.ssh/id_rsa.pub /home/{username}/.ssh/authorized_keys
+                sudo chown -R {username}:{username} /home/{username}/.ssh
+                sudo chmod 700 /home/{username}/.ssh
+                sudo chmod 600 /home/{username}/.ssh/authorized_keys
+                '''
+            ], check=False)
+            
+            # Start SSH service
+            subprocess.run([
+                'bash', '-c',
+                'sudo systemctl start ssh || sudo service ssh start'
+            ], check=False)
+            
+        except Exception as e:
+            print(f"Warning: Some SSH setup steps failed: {e}")
+    
+    def stop_process(self, component: str) -> bool:
+        """Stop FRP process"""
+        pid_file = self.pid_dir / f'frp{component[0]}.pid'
+        
+        if not pid_file.exists():
+            return True
+        
+        try:
+            with open(pid_file, 'r') as f:
+                pid = int(f.read().strip())
+            
+            # Try to terminate gracefully
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(2)
+            
+            # Force kill if still running
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except ProcessLookupError:
+                pass  # Process already dead
+            
+            # Remove PID file
+            pid_file.unlink()
+            return True
+            
+        except Exception as e:
+            print(f"Error stopping {component}: {e}")
+            return False
+    
+    def stop_all(self):
+        """Stop all FRP processes"""
+        self.stop_process('server')
+        self.stop_process('client')
+    
+    def get_status(self) -> Dict[str, bool]:
+        """Get status of FRP processes"""
+        return {
+            'server_running': self._is_process_running('server'),
+            'client_running': self._is_process_running('client')
+        }
+    
+    def _is_process_running(self, component: str) -> bool:
+        """Check if process is running"""
+        pid_file = self.pid_dir / f'frp{component[0]}.pid'
+        
+        if not pid_file.exists():
+            return False
+        
+        try:
+            with open(pid_file, 'r') as f:
+                pid = int(f.read().strip())
+            
+            # Check if process exists
+            os.kill(pid, 0)
+            return True
+            
+        except (ProcessLookupError, ValueError, OSError):
+            # Remove stale PID file
+            if pid_file.exists():
+                pid_file.unlink()
+            return False
+    
+    def get_logs(self, lines: int = 20) -> List[str]:
+        """Get recent log lines"""
+        logs = []
+        
+        for component in ['server', 'client']:
+            log_path = self.config_manager.get_log_path(component)
+            if log_path.exists():
+                try:
+                    with open(log_path, 'r') as f:
+                        log_lines = f.readlines()
+                        recent_lines = log_lines[-lines:]
+                        logs.extend([f"[{component}] {line.strip()}" for line in recent_lines])
+                except Exception:
+                    pass
+        
+        return logs
+    
+    def clean_cache(self):
+        """Clean cache and temporary files"""
+        import shutil
+        
+        # Clean extracted binaries
+        extracted_path = Path.home() / '.frp-tunnel' / 'bin' / 'extracted'
+        if extracted_path.exists():
+            shutil.rmtree(extracted_path)
+        
+        # Clean old log files
+        for log_file in self.config_manager.config_dir.glob('*.log.*'):
+            log_file.unlink()

frp_tunnel-1.0.4.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: frp-tunnel
+Version: 1.0.4
+Summary: Easy SSH tunneling with FRP - One command setup for Google Colab and remote servers
+Author-email: Your Name <your.email@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cicy-dev/frp-tunnel
+Project-URL: Repository, https://github.com/cicy-dev/frp-tunnel.git
+Project-URL: Issues, https://github.com/cicy-dev/frp-tunnel/issues
+Project-URL: Documentation, https://github.com/cicy-dev/frp-tunnel/docs
+Keywords: frp,ssh,tunnel,proxy,colab,remote,development
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=12.0.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pyyaml>=5.4.0
+Requires-Dist: psutil>=5.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.8; extra == "dev"
+Requires-Dist: mypy>=0.800; extra == "dev"
+Dynamic: license-file
+
+# 🚀 FRP Tunnel - SSH Access Made Easy
+
+**[中文文档](README_CN.md) | [English](README.md)**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Platform](https://img.shields.io/badge/Platform-Linux%20%7C%20Windows%20%7C%20macOS-blue.svg)](https://github.com/cicy-dev/frp-tunnel)
+
+> **Connect to Google Colab or any remote server via SSH in 30 seconds. No complex setup needed!**
+
+## 🎯 What This Does
+
+- **Problem**: Can't SSH into Google Colab or access remote servers behind firewalls
+- **Solution**: Creates a secure tunnel so you can SSH from anywhere
+- **Result**: Use your favorite tools (VS Code, file transfer, etc.) with remote servers
+
+## 🏗️ How It Works
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Local Client  │    │   GCP Server    │    │  Google Colab   │
+│  (Any Platform) │    │   (frps:7000)   │    │  (frpc+SSH)     │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │ SSH -p 6001-6010     │                       │
+         └──────────────────────┼───────────────────────┘
+                                │
+                         FRP Tunnel Forwarding
+                      6001-6010 → Target:22
+```
+
+## ⚡ Quick Start (3 Steps)
+
+### Step 1: Install
+```bash
+pip install frp-tunnel
+```
+
+### Step 2: Set Up Server (One-time)
+```bash
+# On your VPS/cloud server
+frp-tunnel setup
+```
+*Follow the prompts - it takes 30 seconds*
+
+### Step 3: Connect from Anywhere
+```bash
+# Google Colab (paste in notebook)
+!pip install frp-tunnel && frp-tunnel colab --server YOUR_SERVER_IP --token YOUR_TOKEN
+
+# Your computer
+frp-tunnel client --server YOUR_SERVER_IP --token YOUR_TOKEN
+
+# Then SSH normally
+ssh -p 6001 colab@YOUR_SERVER_IP
+```
+
+## 🔧 Real-World Examples
+
+### Example 1: Access Google Colab Files
+```python
+# In Colab notebook
+!pip install frp-tunnel && frp-tunnel colab --server 34.123.45.67 --token abc123
+```
+```bash
+# On your computer
+ssh -p 6001 colab@34.123.45.67
+# Now you can browse files, upload/download, use git, etc.
+```
+
+### Example 2: VS Code Remote Development
+1. Set up tunnel (steps above)
+2. In VS Code: Install "Remote-SSH" extension
+3. Connect to `colab@YOUR_SERVER_IP:6001`
+4. Code directly in Colab with full VS Code features!
+
+### Example 3: Multiple Connections
+```bash
+# Colab 1
+frp-tunnel colab --server YOUR_IP --token YOUR_TOKEN --port 6001
+
+# Colab 2  
+frp-tunnel colab --server YOUR_IP --token YOUR_TOKEN --port 6002
+
+# Your laptop
+frp-tunnel client --server YOUR_IP --token YOUR_TOKEN --port 6003
+```
+
+## 🛠️ Troubleshooting (Common Issues)
+
+### "Connection refused"
+```bash
+# Check if server is running
+ssh YOUR_SERVER_IP "ps aux | grep frps"
+```
+
+### "Permission denied"
+```bash
+# Make sure you're using the right port
+ssh -p 6001 colab@YOUR_SERVER_IP  # Not port 22!
+```
+
+### "Token mismatch"
+```bash
+# Get the token from your server
+ssh YOUR_SERVER_IP "cat ~/data/frp/frps.ini | grep token"
+```
+
+## 📋 What You Need
+
+- **Server**: Any Linux VPS (Google Cloud, AWS, DigitalOcean, etc.)
+- **Ports**: Open ports 6001-6010 and 7000 on your server
+- **Client**: Any computer with SSH (Windows/Mac/Linux)
+
+### Quick Server Setup (GCP/AWS)
+```bash
+# Open firewall ports
+gcloud compute firewall-rules create frp-tunnel --allow tcp:6001-6010,tcp:7000
+
+# Or for AWS
+aws ec2 authorize-security-group-ingress --group-id sg-xxxxx --protocol tcp --port 6001-6010 --cidr 0.0.0.0/0
+```
+
+## 🎉 That's It!
+
+No complex configuration files, no networking knowledge needed. Just install, run, and connect!
+
+**Need help?** [Open an issue](https://github.com/cicy-dev/frp-tunnel/issues) - we respond quickly!
+
+---
+
+⭐ **Star this repo if it saved you time!**

frp_tunnel-1.0.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+frp_tunnel/__init__.py,sha256=xef6hdo6PQOVvOmCnQqJJ708jGKFZ3wtioy6pQNX3Bk,153
+frp_tunnel/_version.py,sha256=R604FHUDDjGzi5hem3DYdlBvcBVjznL7PmfCQFtRkDI,18
+frp_tunnel/cli.py,sha256=73AgYgzK1A3tKiSS78zs_FjDXlEkZctP8uecmszrCms,5389
+frp_tunnel/core/__init__.py,sha256=4KMZCKElGqspMj3rgyKK04hZJ1f-DCrhk0IzLOGRLfI,384
+frp_tunnel/core/config.py,sha256=25EdLN0lKpZlnPjd3umDtKturpkaIZxFFwlAcORZV1Y,2713
+frp_tunnel/core/installer.py,sha256=53CKUUB0ExCF2h_zBW17QRw0xe8dhY9prQ1S2ZqaD6c,4098
+frp_tunnel/core/platform.py,sha256=1E4knN-lKUp97kArbCr0jumU3l34lzqVTNvciFLvanw,2569
+frp_tunnel/core/tunnel.py,sha256=rZtCFs3KsOZSO1M1Nl2TnTLgHGZOF-T_0iqBHXvecR4,6930
+frp_tunnel-1.0.4.dist-info/licenses/LICENSE,sha256=olOm-Mwd2NnXAzpefs0sowX0uPN7gio-g1KxpEv6Lvs,1079
+frp_tunnel-1.0.4.dist-info/METADATA,sha256=JkH_7T42Z6XWf7nhPTXnSDjFSwTxiMTOerhWkh9RSIY,5787
+frp_tunnel-1.0.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+frp_tunnel-1.0.4.dist-info/entry_points.txt,sha256=zJ-DXLnJyhjkPC-sLMPLgxm53seoVFCqMo7kDXiYHig,77
+frp_tunnel-1.0.4.dist-info/top_level.txt,sha256=KwiOTKTjTUQkJbD0Ae6Ym9HRvNjKwVo0BO4YNQf2Vzc,11
+frp_tunnel-1.0.4.dist-info/RECORD,,

frp_tunnel-1.0.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

frp_tunnel-1.0.4.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+frp = frp_tunnel.cli:main
+frp-tunnel = frp_tunnel.cli:main

frp_tunnel-1.0.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FRP SSH Tunnel Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

frp_tunnel-1.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+frp_tunnel