unitlab 2.3.3__py3-none-any.whl → 2.3.4__py3-none-any.whl

unitlab/tunnel_config.py

@@ -1,192 +1,161 @@
 """
-Cloudflare Tunnel Configuration for persistent subdomains
+Cloudflare Tunnel Configuration using Service Token
+No user login required - uses pre-generated service token
 """
 
-import json
+import os
 import subprocess
 import socket
 import time
-import yaml
-from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class CloudflareTunnel:
-    def __init__(self, base_domain, device_id):
-        # Hardcode the base domain here
-        self.base_domain = "1scan.uz"  # HARDCODED - ignore the passed base_domain
+    def __init__(self, base_domain, device_id):  # base_domain kept for compatibility
+        """
+        Initialize tunnel with service token
+        No login or credential files needed
+        """
+        # Configuration
+        self.base_domain = "1scan.uz"  # Hardcoded domain
         self.device_id = device_id
         self.hostname = socket.gethostname()
-        self.tunnel_name = f"device-{device_id}"
-        self.config_dir = Path.home() / ".cloudflared"
-        self.config_dir.mkdir(exist_ok=True)
+        
+        # Service token - replace with your actual token from cloudflared tunnel token command
+        # This token can ONLY run the tunnel, cannot modify or delete it
+        # To generate: cloudflared tunnel token unitlab-shared
+        self.service_token = os.getenv(
+            "CLOUDFLARE_TUNNEL_TOKEN",
+            "eyJhIjoiYzkxMTkyYWUyMGE1ZDQzZjY1ZTA4NzU1MGQ4ZGM4OWIiLCJzIjoiZmdnSHowbFJFRnBHa05TZzIzV3JKMVBiaDVROGVUd0oyYWtJWThXdjhtTT0iLCJ0IjoiYjMzZGFhOGYtMmNjMy00Y2FkLWEyMjgtOTdlMDYwNzBlNjAwIn0="  # Replace this with your actual token from step 1
+        )
+        
+        if self.service_token == "YOUR_SERVICE_TOKEN_HERE":
+            logger.warning(
+                "⚠️  No service token configured. "
+                "Set CLOUDFLARE_TUNNEL_TOKEN env var or update the token in tunnel_config.py"
+            )
         
         # Subdomain names
         self.jupyter_subdomain = f"jupyter-{device_id}"
         self.ssh_subdomain = f"ssh-{device_id}"
         
-        # Full URLs - using hardcoded base_domain
+        # Full URLs
         self.jupyter_url = f"https://{self.jupyter_subdomain}.{self.base_domain}"
         self.ssh_url = f"https://{self.ssh_subdomain}.{self.base_domain}"
         
-        self.tunnel_uuid = None
-        self.credentials_file = None
+        self.tunnel_process = None
 
-    def login(self):
-        """Login to Cloudflare (one-time setup)"""
+    def check_cloudflared_installed(self):
+        """Check if cloudflared is installed"""
         try:
-            print("🔐 Checking Cloudflare authentication...")
             result = subprocess.run(
-                ["cloudflared", "tunnel", "login"],
+                ["cloudflared", "--version"],
                 capture_output=True,
                 text=True
             )
-            if result.returncode == 0:
-                print("✅ Cloudflare authentication successful")
-                return True
-            else:
-                print("❌ Cloudflare authentication failed")
-                return False
-        except Exception as e:
-            print(f"❌ Error during Cloudflare login: {e}")
+            return result.returncode == 0
+        except FileNotFoundError:
             return False
 
-    def create_tunnel(self):
-        """Create a named tunnel"""
+    def install_cloudflared(self):
+        """Auto-install cloudflared if not present"""
+        import platform
+        
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+        
+        print("📦 Installing cloudflared...")
+        
         try:
-            print(f"🚇 Creating tunnel: {self.tunnel_name}")
-            
-            # Check if tunnel already exists
-            list_result = subprocess.run(
-                ["cloudflared", "tunnel", "list", "--output", "json"],
-                capture_output=True,
-                text=True
-            )
-            
-            if list_result.returncode == 0:
-                tunnels = json.loads(list_result.stdout)
-                for tunnel in tunnels:
-                    if tunnel.get("name") == self.tunnel_name:
-                        self.tunnel_uuid = tunnel.get("id")
-                        print(f"✅ Tunnel already exists with ID: {self.tunnel_uuid}")
-                        self.credentials_file = self.config_dir / f"{self.tunnel_uuid}.json"
-                        return True
-            
-            # Create new tunnel
-            result = subprocess.run(
-                ["cloudflared", "tunnel", "create", self.tunnel_name],
-                capture_output=True,
-                text=True
-            )
-            
-            if result.returncode == 0:
-                for line in result.stdout.split('\n'):
-                    if "Created tunnel" in line and "with id" in line:
-                        self.tunnel_uuid = line.split("with id")[1].strip()
-                        break
+            if system == "linux":
+                # Determine architecture
+                if machine in ["x86_64", "amd64"]:
+                    arch = "amd64"
+                elif machine in ["aarch64", "arm64"]:
+                    arch = "arm64"
+                else:
+                    arch = "386"
                 
-                if not self.tunnel_uuid:
-                    list_result = subprocess.run(
-                        ["cloudflared", "tunnel", "list", "--output", "json"],
-                        capture_output=True,
-                        text=True
-                    )
-                    if list_result.returncode == 0:
-                        tunnels = json.loads(list_result.stdout)
-                        for tunnel in tunnels:
-                            if tunnel.get("name") == self.tunnel_name:
-                                self.tunnel_uuid = tunnel.get("id")
-                                break
+                # Download and install
+                url = f"https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{arch}"
                 
-                if self.tunnel_uuid:
-                    self.credentials_file = self.config_dir / f"{self.tunnel_uuid}.json"
-                    print(f"✅ Tunnel created with ID: {self.tunnel_uuid}")
-                    return True
-                    
-            print(f"❌ Failed to create tunnel: {result.stderr}")
-            return False
-            
-        except Exception as e:
-            print(f"❌ Error creating tunnel: {e}")
-            return False
-
-    def configure_dns(self):
-        """Configure DNS routes for the tunnel"""
-        try:
-            print("🌐 Configuring DNS routes...")
-            
-            # Route for Jupyter
-            jupyter_result = subprocess.run(
-                ["cloudflared", "tunnel", "route", "dns", 
-                 self.tunnel_name, f"{self.jupyter_subdomain}.{self.base_domain}"],
-                capture_output=True,
-                text=True
-            )
-            
-            if jupyter_result.returncode == 0:
-                print(f"✅ Jupyter route configured: {self.jupyter_url}")
-            else:
-                print(f"⚠️  Jupyter route may already exist or failed: {jupyter_result.stderr}")
-            
-            # Route for SSH
-            ssh_result = subprocess.run(
-                ["cloudflared", "tunnel", "route", "dns",
-                 self.tunnel_name, f"{self.ssh_subdomain}.{self.base_domain}"],
-                capture_output=True,
-                text=True
-            )
-            
-            if ssh_result.returncode == 0:
-                print(f"✅ SSH route configured: {self.ssh_url}")
-            else:
-                print(f"⚠️  SSH route may already exist or failed: {ssh_result.stderr}")
+                commands = [
+                    f"curl -L {url} -o /tmp/cloudflared",
+                    "chmod +x /tmp/cloudflared",
+                    "sudo mv /tmp/cloudflared /usr/local/bin/cloudflared 2>/dev/null || "
+                    "mkdir -p ~/.local/bin && mv /tmp/cloudflared ~/.local/bin/cloudflared"
+                ]
+                
+                for cmd in commands:
+                    subprocess.run(cmd, shell=True, check=False)
+                
+                # Add ~/.local/bin to PATH if needed
+                local_bin = os.path.expanduser("~/.local/bin")
+                if local_bin not in os.environ.get("PATH", ""):
+                    os.environ["PATH"] = f"{local_bin}:{os.environ['PATH']}"
+                
+                return self.check_cloudflared_installed()
+                
+            elif system == "darwin":
+                # Try homebrew first
+                result = subprocess.run(["brew", "install", "cloudflared"], capture_output=True)
+                if result.returncode != 0:
+                    # Fallback to direct download
+                    url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64.tgz"
+                    subprocess.run(f"curl -L {url} | tar xz", shell=True)
+                    subprocess.run("sudo mv cloudflared /usr/local/bin/", shell=True)
+                
+                return self.check_cloudflared_installed()
+                
+            elif system == "windows":
+                print("⚠️  Please install cloudflared manually on Windows")
+                print("   Download from: https://github.com/cloudflare/cloudflared/releases")
+                return False
                 
-            return True
-            
         except Exception as e:
-            print(f"❌ Error configuring DNS: {e}")
+            logger.error(f"Failed to install cloudflared: {e}")
             return False
 
-    def create_config_file(self, jupyter_port):
-        """Create tunnel configuration file"""
-        config = {
-            "tunnel": self.tunnel_uuid,
-            "credentials-file": str(self.credentials_file),
-            "ingress": [
-                {
-                    "hostname": f"{self.jupyter_subdomain}.{self.base_domain}",
-                    "service": f"http://localhost:{jupyter_port}",
-                    "originRequest": {
-                        "noTLSVerify": True
-                    }
-                },
-                {
-                    "hostname": f"{self.ssh_subdomain}.{self.base_domain}",
-                    "service": "ssh://localhost:22",
-                    "originRequest": {
-                        "noTLSVerify": True
-                    }
-                },
-                {
-                    "service": "http_status:404"
-                }
-            ]
-        }
+    def setup(self, jupyter_port):  # jupyter_port kept for compatibility
+        """
+        Setup and start tunnel with service token
+        No login required!
+        """
+        print("🚀 Setting up Cloudflare tunnel with service token...")
         
-        config_file = self.config_dir / f"config-{self.device_id}.yml"
-        with open(config_file, 'w') as f:
-            yaml.dump(config, f, default_flow_style=False)
+        # Check if cloudflared is installed
+        if not self.check_cloudflared_installed():
+            print("cloudflared not found, attempting to install...")
+            if not self.install_cloudflared():
+                print("❌ Failed to install cloudflared. Please install it manually:")
+                print("   https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/")
+                return None
         
-        print(f"📝 Configuration saved to: {config_file}")
-        return config_file
+        # Start tunnel with service token
+        return self.start_tunnel_with_token()
 
-    def start_tunnel(self, config_file):
-        """Start the tunnel with the configuration"""
+    def start_tunnel_with_token(self):
+        """
+        Start the tunnel using service token
+        This is much simpler than the credential file approach
+        """
         try:
             print("🚀 Starting Cloudflare tunnel...")
             
-            cmd = ["cloudflared", "tunnel", "--config", str(config_file), "run"]
+            # Simple command with service token
+            cmd = [
+                "cloudflared",
+                "tunnel",
+                "--no-autoupdate",  # Prevent auto-updates during run
+                "run",
+                "--token",
+                self.service_token
+            ]
             
-            process = subprocess.Popen(
+            # Start the tunnel process
+            self.tunnel_process = subprocess.Popen(
                 cmd,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
@@ -195,44 +164,36 @@ class CloudflareTunnel:
             )
             
             # Wait for tunnel to establish
+            print("⏳ Waiting for tunnel to connect...")
             time.sleep(5)
             
-            if process.poll() is None:
-                print("✅ Tunnel is running")
-                return process
+            # Check if process is still running
+            if self.tunnel_process.poll() is None:
+                print("✅ Tunnel is running!")
+                print(f"📌 Jupyter URL: {self.jupyter_url}")
+                print(f"📌 SSH URL: {self.ssh_url}")
+                return self.tunnel_process
             else:
+                # Read any error output
+                output = self.tunnel_process.stdout.read()
                 print("❌ Tunnel failed to start")
+                print(f"Error output: {output}")
                 return None
                 
         except Exception as e:
             print(f"❌ Error starting tunnel: {e}")
             return None
 
-    def setup(self, jupyter_port):
-        """Complete setup process"""
-        # Check if we need to login
-        if not (self.config_dir / "cert.pem").exists():
-            if not self.login():
-                return None
-        
-        # Create tunnel
-        if not self.create_tunnel():
-            return None
-        
-        # Configure DNS
-        if not self.configure_dns():
-            return None
-        
-        # Create config file
-        config_file = self.create_config_file(jupyter_port)
-        
-        # Start tunnel
-        tunnel_process = self.start_tunnel(config_file)
-        
-        if tunnel_process:
-            print("\n✅ Tunnel setup complete!")
-            print(f"📌 Jupyter URL: {self.jupyter_url}")
-            print(f"📌 SSH URL: {self.ssh_url}")
-            return tunnel_process
-        
-        return None
+    def stop(self):
+        """Stop the tunnel if running"""
+        if self.tunnel_process and self.tunnel_process.poll() is None:
+            print("Stopping tunnel...")
+            self.tunnel_process.terminate()
+            self.tunnel_process.wait(timeout=5)
+            print("Tunnel stopped")
+
+    # Removed all the old methods that are no longer needed:
+    # - login() - not needed with service token
+    # - create_tunnel() - tunnel already exists
+    # - configure_dns() - already configured
+    # - create_config_file() - not needed with service token

unitlab/tunnel_service_token.py

@@ -0,0 +1,104 @@
+"""
+Service Token implementation for Cloudflare Tunnel
+More secure than embedding full credentials
+"""
+
+import os
+import subprocess
+import time
+from pathlib import Path
+
+
+class ServiceTokenTunnel:
+    """
+    Use Cloudflare Service Token instead of credentials file
+    This is more secure and doesn't require login
+    """
+    
+    # Embed the service token (generated once by admin)
+    # This token can ONLY run the tunnel, cannot modify it
+    DEFAULT_SERVICE_TOKEN = "eyJhIjoiYzkxMTkyYWUyMGE1ZDQzZjY1ZTA4NzU1MGQ4ZGM4OWIiLCJzIjoiZmdnSHowbFJFRnBHa05TZzIzV3JKMVBiaDVROGVUd0oyYWtJWThXdjhtTT0iLCJ0IjoiYjMzZGFhOGYtMmNjMy00Y2FkLWEyMjgtOTdlMDYwNzBlNjAwIn0="
+    
+    def __init__(self, device_id, service_token=None):
+        self.device_id = device_id
+        # Allow override via environment variable or parameter
+        self.service_token = (
+            service_token or 
+            os.getenv("CLOUDFLARE_TUNNEL_TOKEN") or 
+            self.DEFAULT_SERVICE_TOKEN
+        )
+        
+        # With service token, we don't need credential files
+        # The token contains all necessary information
+        
+    def start_tunnel_with_token(self):
+        """
+        Start tunnel using service token
+        No login, no credential files needed
+        """
+        print("🚀 Starting tunnel with service token...")
+        
+        # Service token method - super simple!
+        cmd = [
+            "cloudflared", 
+            "tunnel", 
+            "run",
+            "--token",
+            self.service_token
+        ]
+        
+        try:
+            # Start the tunnel
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            # Wait for tunnel to establish
+            time.sleep(3)
+            
+            if process.poll() is None:
+                print("✅ Tunnel running with service token")
+                return process
+            else:
+                print("❌ Failed to start tunnel")
+                return None
+                
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            return None
+    
+    def get_tunnel_info(self):
+        """
+        Service tokens use predetermined URLs
+        The admin sets these up when creating the tunnel
+        """
+        # These URLs are configured when creating the tunnel
+        base_domain = "1scan.uz"
+        return {
+            "jupyter_url": f"https://jupyter-{self.device_id}.{base_domain}",
+            "ssh_url": f"https://ssh-{self.device_id}.{base_domain}"
+        }
+
+
+# Usage example
+def run_with_service_token(device_id):
+    """
+    Example of how simple it is with service token
+    """
+    tunnel = ServiceTokenTunnel(device_id)
+    
+    # No login needed!
+    # No credential files needed!
+    # Just run with the token
+    process = tunnel.start_tunnel_with_token()
+    
+    if process:
+        urls = tunnel.get_tunnel_info()
+        print(f"Jupyter: {urls['jupyter_url']}")
+        print(f"SSH: {urls['ssh_url']}")
+        return process
+    
+    return None

{unitlab-2.3.3.dist-info → unitlab-2.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unitlab
-Version: 2.3.3
+Version: 2.3.4
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai
@@ -23,4 +23,5 @@ Requires-Dist: typer
 Requires-Dist: validators
 Requires-Dist: psutil
 Requires-Dist: pyyaml
+Requires-Dist: jupyter
 

{unitlab-2.3.3.dist-info → unitlab-2.3.4.dist-info}/RECORD

@@ -3,11 +3,12 @@ unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
 unitlab/client.py,sha256=LGbjto3jisF5LojlYjJyLKRc55wxfZTO_tkoipZBKd4,22910
 unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
 unitlab/main.py,sha256=XD8PF_EJ1gAKqHcRT_bWy62LWrODGWMx2roKoaQaoY4,5253
-unitlab/tunnel_config.py,sha256=lfWXKTPKlhHOxECUA0_HhynrKfOZ345nLo0qA7XtfbE,8571
+unitlab/tunnel_config.py,sha256=WhxjuOjvOXz16KbMAgpvbCpRD0Y5y53y9jVizQ7CxR8,7841
+unitlab/tunnel_service_token.py,sha256=ji96a4s4W2cFJrHZle0zBD85Ac_T862-gCKzBUomrxM,3125
 unitlab/utils.py,sha256=83ekAxxfXecFTg76Z62BGDybC_skKJHYoLyawCD9wGM,1920
-unitlab-2.3.3.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
-unitlab-2.3.3.dist-info/METADATA,sha256=pO2UGvjS3FoVgAXZKlHUeBONoWAnLgVkZ2I55UyiSGs,791
-unitlab-2.3.3.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-unitlab-2.3.3.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
-unitlab-2.3.3.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
-unitlab-2.3.3.dist-info/RECORD,,
+unitlab-2.3.4.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
+unitlab-2.3.4.dist-info/METADATA,sha256=4GHYHBRrtcbbHw06gcZ5mfucnjJvOGFC4Y8DvRqw-28,814
+unitlab-2.3.4.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+unitlab-2.3.4.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
+unitlab-2.3.4.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
+unitlab-2.3.4.dist-info/RECORD,,