cpolar-connect 0.1.0.dev0__py3-none-any.whl

cpolar_connect/__init__.py

@@ -0,0 +1,16 @@
+"""
+Cpolar Connect - Easy-to-use CLI tool for cpolar tunnel management and SSH connections
+"""
+
+__version__ = "0.0.1"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"
+
+from .config import ConfigManager, CpolarConfig, ConfigError
+
+__all__ = [
+    "ConfigManager",
+    "CpolarConfig", 
+    "ConfigError",
+    "__version__",
+]

cpolar_connect/auth.py

@@ -0,0 +1,271 @@
+"""
+Authentication module for Cpolar Connect
+"""
+
+import logging
+import requests
+from typing import Optional, Tuple
+from bs4 import BeautifulSoup
+from rich.console import Console
+
+from .config import ConfigManager
+from .exceptions import AuthenticationError, NetworkError
+from .i18n import _
+
+console = Console()
+logger = logging.getLogger(__name__)
+
+
+class CpolarAuth:
+    """Handle cpolar authentication"""
+    
+    def __init__(self, config_manager: ConfigManager):
+        """Initialize authentication with config manager"""
+        self.config_manager = config_manager
+        self.config = config_manager.get_config()
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        })
+        self.base_url = self.config.base_url
+        self.login_url = f"{self.base_url}/login"
+        self.status_url = f"{self.base_url}/status"
+        self.authenticated = False
+    
+    def get_csrf_token(self) -> str:
+        """Get CSRF token from login page"""
+        try:
+            response = self.session.get(self.login_url, timeout=10)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.text, 'html.parser')
+            csrf_input = soup.find("input", {"name": "csrf_token"})
+            
+            if not csrf_input:
+                # Try alternative methods
+                # Sometimes the token might be in meta tag
+                meta_csrf = soup.find("meta", {"name": "csrf-token"})
+                if meta_csrf:
+                    return meta_csrf.get("content", "")
+                
+                logger.error("CSRF token not found in login page")
+                raise AuthenticationError(_('error.csrf_token_not_found'))
+            
+            csrf_token = csrf_input.get("value", "")
+            if not csrf_token:
+                raise AuthenticationError(_('error.csrf_token_empty'))
+            
+            logger.debug("Successfully obtained CSRF token")
+            return csrf_token
+            
+        except requests.RequestException as e:
+            logger.error(f"Network error while getting login page: {e}")
+            raise NetworkError(_('error.network', error=e))
+        except Exception as e:
+            logger.error(f"Error getting CSRF token: {e}")
+            raise AuthenticationError(_('error.auth', error=e))
+    
+    def login(self, username: Optional[str] = None, password: Optional[str] = None) -> requests.Session:
+        """
+        Login to cpolar and return authenticated session
+        
+        Args:
+            username: Override config username if provided
+            password: Override config password if provided
+            
+        Returns:
+            Authenticated requests.Session object
+        """
+        # Get credentials
+        if not username:
+            username = self.config.username
+        
+        if not password:
+            password = self.config_manager.get_password(username)
+            if not password:
+                raise AuthenticationError(_('auth.password_required'))
+        
+        try:
+            # Step 1: Get CSRF token
+            console.print(f"[dim]{_('auth.csrf_token')}[/dim]")
+            csrf_token = self.get_csrf_token()
+            
+            # Step 2: Submit login form
+            console.print(f"[dim]{_('auth.logging_in', username=username)}[/dim]")
+            
+            # Try different field names based on what cpolar might expect
+            login_data = {
+                'login': username,  # or could be 'username' or 'email'
+                'password': password,
+                'csrf_token': csrf_token
+            }
+            
+            # Debug: log the form fields we're sending (without password)
+            logger.debug(f"Login form fields: {list(login_data.keys())}")
+            logger.debug(f"Login URL: {self.login_url}")
+            
+            response = self.session.post(
+                self.login_url, 
+                data=login_data,
+                timeout=10,
+                allow_redirects=False  # Handle redirects manually
+            )
+            
+            # Check for redirect (successful login typically redirects)
+            if response.status_code in [302, 303]:
+                redirect_url = response.headers.get('Location', '')
+                logger.debug(f"Login redirected to: {redirect_url}")
+                
+                # Follow the redirect
+                response = self.session.get(
+                    redirect_url if redirect_url.startswith('http') else f"{self.base_url}{redirect_url}",
+                    timeout=10
+                )
+                response.raise_for_status()
+            else:
+                response.raise_for_status()
+            
+            # Step 3: Verify login success
+            if not self._verify_authentication(response):
+                logger.error("Login verification failed")
+                raise AuthenticationError(_('auth.login_failed'))
+            
+            self.authenticated = True
+            console.print(f"[green]{_('auth.login_success')}[/green]")
+            logger.info(f"Successfully authenticated as {username}")
+            
+            return self.session
+            
+        except requests.RequestException as e:
+            logger.error(f"Network error during login: {e}")
+            raise NetworkError(_('error.network', error=e))
+        except AuthenticationError:
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error during login: {e}")
+            raise AuthenticationError(_('error.auth', error=e))
+    
+    def _verify_authentication(self, response: requests.Response) -> bool:
+        """
+        Verify that authentication was successful
+        
+        Args:
+            response: Response from login POST request
+            
+        Returns:
+            True if authentication successful, False otherwise
+        """
+        response_text = response.text.lower()
+        
+        # Check for success indicators
+        success_indicators = [
+            'logout',
+            'status',
+            'dashboard',
+            'tunnel',
+            '隧道',  # Chinese for tunnel
+            'get-started'  # Cpolar redirect page after login
+        ]
+        
+        # Check for failure indicators (be more specific)
+        failure_indicators = [
+            'login failed',
+            'invalid credentials',
+            'incorrect password',
+            'authentication failed',
+            '登录失败',  # Chinese for login failed
+            '密码错误'   # Chinese for wrong password
+        ]
+        
+        # If we find failure indicators, authentication failed
+        for indicator in failure_indicators:
+            if indicator in response_text:
+                logger.debug(f"Found failure indicator: {indicator}")
+                return False
+        
+        # If we find success indicators, authentication succeeded
+        for indicator in success_indicators:
+            if indicator in response_text:
+                logger.debug(f"Found success indicator: {indicator}")
+                return True
+        
+        # Check if we're still on login page
+        if '/login' in response.url:
+            logger.debug("Still on login page after POST")
+            return False
+        
+        # If redirected to status, dashboard, or get-started, consider it success  
+        if any(path in response.url for path in ['/status', '/dashboard', '/get-started']):
+            logger.debug(f"Redirected to {response.url}")
+            return True
+        
+        # Default to checking for specific text
+        return 'logout' in response_text or 'status' in response_text
+    
+    def logout(self) -> None:
+        """Logout from cpolar"""
+        if not self.authenticated:
+            return
+        
+        try:
+            logout_url = f"{self.base_url}/logout"
+            self.session.get(logout_url, timeout=5)
+            self.authenticated = False
+            logger.info("Logged out from cpolar")
+        except Exception as e:
+            # Logout errors are not critical
+            logger.debug(f"Error during logout: {e}")
+    
+    def test_connection(self) -> bool:
+        """Test connection to cpolar"""
+        try:
+            response = self.session.get(self.base_url, timeout=10)
+            return response.status_code == 200
+        except Exception as e:
+            logger.error(f"Connection test failed: {e}")
+            return False
+    
+    def is_authenticated(self) -> bool:
+        """Check if currently authenticated"""
+        if not self.authenticated:
+            return False
+        
+        # Try to access status page to verify session is still valid
+        try:
+            response = self.session.get(self.status_url, timeout=10, allow_redirects=True)
+            
+            # Check if redirected to login page
+            if '/login' in response.url.lower():
+                self.authenticated = False
+                return False
+            
+            # Check for authentication indicators in response
+            response_text = response.text.lower()
+            if response.status_code == 200:
+                # Look for indicators we're logged in
+                if any(indicator in response_text for indicator in ['logout', 'status', 'tunnel', '隧道']):
+                    return True
+                # If we see login form elements, we're not authenticated
+                if any(indicator in response_text for indicator in ['password', 'login', 'sign in']):
+                    self.authenticated = False
+                    return False
+            
+            return response.status_code == 200
+        except Exception as e:
+            logger.debug(f"Authentication check failed: {e}")
+            self.authenticated = False
+            return False
+    
+    def get_session(self) -> requests.Session:
+        """Get the current session, login if necessary"""
+        if not self.is_authenticated():
+            self.login()
+        return self.session
+    
+    def __enter__(self):
+        """Context manager entry - login"""
+        return self.get_session()
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - logout"""
+        self.logout()

cpolar_connect/cli.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+Cpolar Connect - CLI Entry Point
+"""
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+import sys
+import os
+from getpass import getpass
+
+from .config import ConfigManager, ConfigError
+from .exceptions import AuthenticationError, TunnelError, SSHError, NetworkError
+from .auth import CpolarAuth
+from .tunnel import TunnelManager
+from .ssh import SSHManager
+from .i18n import _, get_i18n, Language
+
+console = Console()
+
+@click.group(invoke_without_command=True)
+@click.version_option(version="0.0.1")
+@click.pass_context
+def cli(ctx):
+    """🚀 Cpolar Connect - Easy cpolar tunnel management and SSH connections"""
+    ctx.ensure_object(dict)
+    ctx.obj['config_manager'] = ConfigManager()
+    
+    # If no command is provided, run the default action (connect)
+    if ctx.invoked_subcommand is None:
+        # Default behavior: update and connect
+        config_manager = ctx.obj['config_manager']
+        
+        if not config_manager.config_exists():
+            console.print(f"[yellow]⚠️ {_('cli.no_config')}[/yellow]")
+            sys.exit(1)
+        
+        try:
+            config = config_manager.get_config()
+            console.print(f"[cyan]🔗 {_('cli.connecting_server')}[/cyan]")
+            
+            # Check password availability
+            password = config_manager.get_password(config.username)
+            if not password:
+                console.print(f"[yellow]⚠️ {_('auth.password_required')}[/yellow]")
+                sys.exit(1)
+            
+            # Execute full connection flow
+            with console.status("[bold green]Connecting to cpolar tunnel...") as status:
+                try:
+                    # 1. Authenticate with cpolar
+                    status.update("[yellow]Authenticating with cpolar...[/yellow]")
+                    auth = CpolarAuth(config_manager)
+                    session = auth.login()
+                    
+                    # 2. Get tunnel information
+                    status.update("[yellow]Fetching tunnel information...[/yellow]")
+                    tunnel_manager = TunnelManager(session, config.base_url)
+                    tunnel_info = tunnel_manager.get_tunnel_info()
+                    
+                    # 3. Setup SSH and connect
+                    status.update("[yellow]Setting up SSH connection...[/yellow]")
+                    ssh_manager = SSHManager(config)
+                    
+                    # Get server password if needed (for first-time key upload)
+                    server_password = None
+                    if not ssh_manager.test_ssh_connection(tunnel_info.hostname, tunnel_info.port):
+                        console.print(f"\n[yellow]{_('warning.first_connection')}[/yellow]")
+                        server_password = getpass(f"Enter password for {config.server_user}@{tunnel_info.hostname}: ")
+                    
+                    # Setup and connect
+                    ssh_manager.setup_and_connect(tunnel_info, server_password)
+                    
+                except (AuthenticationError, TunnelError, SSHError, NetworkError) as e:
+                    console.print(f"[red]❌ {_('error.connection_failed', error=e)}[/red]")
+                    sys.exit(1)
+                finally:
+                    # Clean logout
+                    if 'auth' in locals():
+                        auth.logout()
+            
+        except ConfigError as e:
+            console.print(f"[red]❌ {_('error.config', error=e)}[/red]")
+            sys.exit(1)
+
+@cli.command()
+@click.option('--force', '-f', is_flag=True, help='Overwrite existing configuration')
+@click.pass_context
+def init(ctx, force):
+    """🔧 Initialize configuration file"""
+    config_manager = ctx.obj['config_manager']
+    
+    if config_manager.config_exists() and not force:
+        if not Confirm.ask(_('warning.config_exists')):
+            console.print(f"[yellow]{_('warning.config_cancelled')}[/yellow]")
+            return
+    
+    console.print(Panel.fit("🔧 [bold]Cpolar Connect Setup[/bold]", border_style="blue"))
+    
+    # Collect basic configuration
+    console.print("\n[bold cyan]Basic Configuration[/bold cyan]")
+    
+    username = Prompt.ask(_('cli.enter_username'))
+    server_user = Prompt.ask(_('cli.enter_server_user')) 
+    
+    # Parse ports
+    ports_input = Prompt.ask(_('cli.enter_ports'), default="8888,6666")
+    try:
+        ports = [int(p.strip()) for p in ports_input.split(',')]
+    except ValueError:
+        console.print(f"[red]❌ {_('warning.invalid_port_format')}[/red]")
+        sys.exit(1)
+    
+    auto_connect = Confirm.ask("Auto-connect after update?", default=True)
+    
+    # Create configuration
+    config_data = {
+        'username': username,
+        'server_user': server_user,
+        'ports': ports,
+        'auto_connect': auto_connect
+    }
+    
+    try:
+        config_manager.create_config(config_data)
+        console.print(f"\n[green]{_('cli.config_created')}[/green]")
+        console.print(f"📁 Configuration saved to: {config_manager.config_path}")
+        
+        # Prompt for password storage
+        store_password = Confirm.ask(_('cli.store_password'), default=True)
+        if store_password:
+            password = getpass(f"{_('cli.enter_password')}: ")
+            if password:
+                config_manager.set_password(username, password)
+        
+        console.print(f"\n[yellow]💡 {_('info.env_password_tip')}[/yellow]")
+        console.print(f"[yellow]💡 {_('info.config_show_tip')}[/yellow]")
+        
+    except ConfigError as e:
+        console.print(f"[red]❌ {_('error.config_create_failed', error=e)}[/red]")
+        sys.exit(1)
+
+# TODO: Implement after creating auth, tunnel, and ssh modules
+# @cli.command() 
+# def connect():
+#     """🔗 Connect to server via SSH"""
+#     pass
+
+# @cli.command()
+# def update():
+#     """🔄 Update tunnel information and SSH configuration"""
+#     pass
+
+# @cli.command()
+# def status():
+#     """📊 Show current tunnel status"""
+#     pass
+
+@cli.group()
+def config():
+    """⚙️ Configuration management"""
+    pass
+
+@config.command('get')
+@click.argument('key')
+@click.pass_context
+def config_get(ctx, key):
+    """Get configuration value"""
+    config_manager = ctx.obj['config_manager']
+    try:
+        value = config_manager.get(key)
+        console.print(f"[cyan]{key}[/cyan]: [white]{value}[/white]")
+    except KeyError:
+        console.print(f"[red]❌ {_('error.config_key_not_found', key=key)}[/red]")
+        sys.exit(1)
+    except ConfigError as e:
+        console.print(f"[red]❌ {_('error.config', error=e)}[/red]")
+        sys.exit(1)
+
+@config.command('set')
+@click.argument('key')
+@click.argument('value')
+@click.pass_context
+def config_set(ctx, key, value):
+    """Set configuration value"""
+    config_manager = ctx.obj['config_manager']
+    try:
+        config_manager.set(key, value)
+        console.print(f"[green]{_('cli.config_updated', key=key, value=value)}[/green]")
+    except ConfigError as e:
+        console.print(f"[red]❌ {_('error.config', error=e)}[/red]")
+        sys.exit(1)
+
+@config.command('edit')
+@click.pass_context
+def config_edit(ctx):
+    """Edit configuration file in default editor"""
+    config_manager = ctx.obj['config_manager']
+    try:
+        config_manager.edit()
+        console.print(f"[green]✅ {_('info.config_opened')}[/green]")
+    except ConfigError as e:
+        console.print(f"[red]❌ {_('error.config_edit_failed', error=e)}[/red]")
+        sys.exit(1)
+
+@config.command('show')
+@click.pass_context
+def config_show(ctx):
+    """Show current configuration"""
+    config_manager = ctx.obj['config_manager']
+    try:
+        config_manager.display()
+    except ConfigError as e:
+        console.print(f"[red]❌ {_('error.config', error=e)}[/red]")
+        console.print(f"[yellow]💡 {_('info.run_init')}[/yellow]")
+        sys.exit(1)
+
+@config.command('path')
+@click.pass_context  
+def config_path(ctx):
+    """Show configuration file path"""
+    config_manager = ctx.obj['config_manager']
+    console.print(f"📁 Config file: [cyan]{config_manager.config_path}[/cyan]")
+    console.print(f"📁 Logs directory: [cyan]{config_manager.logs_path}[/cyan]")
+
+@config.command('clear-password')
+@click.pass_context
+def config_clear_password(ctx):
+    """Clear stored password from keyring"""
+    config_manager = ctx.obj['config_manager']
+    try:
+        config = config_manager.get_config()
+        config_manager.clear_password(config.username)
+    except ConfigError as e:
+        console.print(f"[red]❌ {_('error.config', error=e)}[/red]")
+        sys.exit(1)
+
+@cli.command('language')
+@click.argument('lang', type=click.Choice(['zh', 'en', 'chinese', 'english']))
+@click.pass_context
+def set_language(ctx, lang):
+    """Set interface language / 设置界面语言
+    
+    Examples:
+        cpolar-connect language zh      # 设置中文
+        cpolar-connect language en      # Set English
+    """
+    config_manager = ctx.obj['config_manager']
+    
+    # Normalize language code
+    if lang in ['chinese', 'zh']:
+        lang_code = 'zh'
+        lang_name = '中文'
+    else:
+        lang_code = 'en'
+        lang_name = 'English'
+    
+    try:
+        # Load config
+        config = config_manager.get_config()
+        
+        # Update language
+        config.language = lang_code
+        config_manager.save_config(config)
+        
+        # Apply immediately
+        from .i18n import set_language, Language
+        set_language(Language.ZH if lang_code == 'zh' else Language.EN)
+        
+        # Show success message in new language
+        if lang_code == 'zh':
+            console.print(f"[green]✅ 界面语言已设置为 {lang_name}[/green]")
+            console.print("[dim]重新运行命令以使用新语言[/dim]")
+        else:
+            console.print(f"[green]✅ Interface language set to {lang_name}[/green]")
+            console.print("[dim]Restart the command to use the new language[/dim]")
+            
+    except ConfigError as e:
+        console.print(f"[red]❌ {_('error.config', error=e)}[/red]")
+        sys.exit(1)
+
+@cli.command('doctor')
+@click.pass_context
+def doctor_cmd(ctx):
+    """🏥 Diagnose connection problems / 诊断连接问题
+    
+    This command checks:
+    - Configuration validity
+    - Network connectivity  
+    - Cpolar authentication
+    - SSH setup
+    - Active tunnels
+    
+    Use this when you have connection issues.
+    """
+    from .doctor import Doctor
+    
+    doctor = Doctor()
+    success = doctor.run()
+    
+    if not success:
+        sys.exit(1)
+
+def main():
+    """Entry point for the CLI"""
+    cli()
+
+if __name__ == '__main__':
+    main()