unitlab 2.3.20__tar.gz → 2.3.23__tar.gz

{unitlab-2.3.20/src/unitlab.egg-info → unitlab-2.3.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unitlab
-Version: 2.3.20
+Version: 2.3.23
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai

{unitlab-2.3.20 → unitlab-2.3.23}/setup.py

@@ -2,7 +2,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="unitlab",
-    version="2.3.20",
+    version="2.3.23",
     license="MIT",
     author="Unitlab Inc.",
     author_email="team@unitlab.ai",

unitlab-2.3.23/src/unitlab/cloudflare_api_tunnel.py

@@ -0,0 +1,367 @@
+"""
+Cloudflare API-based Tunnel Configuration
+Uses API to dynamically manage DNS and routes
+SIMPLIFIED VERSION with unique tunnel names
+"""
+
+import os
+import requests
+import subprocess
+import time
+import logging
+import uuid
+from pathlib import Path
+from .binary_manager import CloudflaredBinaryManager
+
+# Try to load .env file if it exists
+try:
+    from dotenv import load_dotenv
+    env_path = Path(__file__).parent.parent.parent / '.env'
+    if env_path.exists():
+        load_dotenv(env_path)
+except ImportError:
+    pass
+
+class CloudflareAPITunnel:
+    def __init__(self, device_id, base_domain="1scan.uz"):
+        """
+        Initialize Cloudflare tunnel with API configuration
+        Each device gets a unique tunnel with UUID
+        """
+        self.device_id = device_id
+        self.base_domain = base_domain
+        
+        # Clean device ID for use in hostnames (remove special chars)
+        self.clean_device_id = device_id.replace(' ', '').replace('-', '').replace('.', '').replace('_', '')[:24]
+        
+        # Subdomains for this device (j for jupyter, s for ssh)
+        self.jupyter_subdomain = f"j{self.clean_device_id}"
+        self.ssh_subdomain = f"s{self.clean_device_id}"
+        
+        # URLs for access
+        self.jupyter_url = f"https://{self.jupyter_subdomain}.{base_domain}"
+        self.ssh_hostname = f"{self.ssh_subdomain}.{base_domain}"
+        self.ssh_url = self.ssh_hostname  # Backward compatibility
+        
+        # Hardcoded Cloudflare credentials
+        self.account_id = "c91192ae20a5d43f65e087550d8dc89b"
+        self.api_token = "xkfCGvxHeiU7xvz0OhfYUICZvJ7rM4NmgdMSB5jy"
+        self.zone_id = "f17ca0e9cf056e87afb019c88f936ac9"
+        
+        # API configuration
+        self.api_base = "https://api.cloudflare.com/client/v4"
+        self.headers = {
+            "Authorization": f"Bearer {self.api_token}",
+            "Content-Type": "application/json"
+        }
+        
+        # Track created resources for cleanup
+        self.tunnel_id = None
+        self.tunnel_process = None
+        self.created_dns_records = []
+        self.tunnel_config_file = None
+        
+        # Binary manager for cloudflared
+        self.binary_manager = CloudflaredBinaryManager()
+    
+    def create_dns_records(self):
+        """
+        Create DNS records pointing to the tunnel
+        """
+        if not self.api_token or not self.tunnel_id:
+            print("⚠️  Cannot create DNS records without API token and tunnel ID")
+            return False
+            
+        print(f"📡 Creating DNS records for device {self.device_id}...")
+        
+        dns_records = [
+            {"name": self.jupyter_subdomain, "content": f"{self.tunnel_id}.cfargotunnel.com"},
+            {"name": self.ssh_subdomain, "content": f"{self.tunnel_id}.cfargotunnel.com"}
+        ]
+        
+        for record in dns_records:
+            try:
+                # Check if record exists
+                check_url = f"{self.api_base}/zones/{self.zone_id}/dns_records"
+                check_params = {"name": f"{record['name']}.{self.base_domain}", "type": "CNAME"}
+                check_response = requests.get(check_url, headers=self.headers, params=check_params)
+                
+                if check_response.status_code == 200:
+                    existing = check_response.json().get('result', [])
+                    if existing:
+                        print(f"   ✓ DNS record {record['name']}.{self.base_domain} already exists")
+                        continue
+                
+                # Create new record
+                data = {
+                    "type": "CNAME",
+                    "name": record['name'],
+                    "content": record['content'],
+                    "ttl": 1,
+                    "proxied": True
+                }
+                
+                response = requests.post(check_url, headers=self.headers, json=data)
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    if result.get("success"):
+                        print(f"   ✅ Created DNS: {record['name']}.{self.base_domain}")
+                        self.created_dns_records.append(result["result"]["id"])
+                    else:
+                        print(f"   ⚠️  Failed to create {record['name']}: {result.get('errors')}")
+                else:
+                    print(f"   ❌ HTTP error {response.status_code} for {record['name']}")
+                    
+            except Exception as e:
+                print(f"   ❌ Error creating DNS record: {e}")
+                continue
+        
+        return True
+    
+    def create_device_tunnel(self):
+        """
+        Create a unique tunnel for this device
+        Each tunnel gets a unique UUID to avoid conflicts
+        """
+        # Always use a unique name with UUID
+        unique_id = str(uuid.uuid4())[:8]
+        tunnel_name = f"device-{self.clean_device_id}-{unique_id}"
+        
+        print(f"📦 Creating new tunnel: {tunnel_name}")
+        
+        create_url = f"{self.api_base}/accounts/{self.account_id}/tunnels"
+        
+        # Generate secret
+        tunnel_secret = os.urandom(32).hex()
+        
+        create_data = {
+            "name": tunnel_name,
+            "tunnel_secret": tunnel_secret
+        }
+        
+        create_response = requests.post(create_url, headers=self.headers, json=create_data)
+        
+        if create_response.status_code in [200, 201]:
+            tunnel = create_response.json()['result']
+            print(f"✅ Created tunnel: {tunnel_name}")
+            
+            # Add the secret to the tunnel info (API doesn't return it)
+            tunnel['tunnel_secret'] = tunnel_secret
+            
+            # Save credentials for this tunnel
+            self._save_tunnel_credentials(tunnel)
+            
+            # Configure tunnel routes
+            self._configure_tunnel_routes(tunnel['id'])
+            
+            # Store tunnel ID for DNS creation
+            self.tunnel_id = tunnel['id']
+            
+            # Create DNS records for this device
+            self.create_dns_records()
+            
+            return tunnel
+        else:
+            print(f"❌ Failed to create tunnel: {create_response.text}")
+            return None
+    
+    def _configure_tunnel_routes(self, tunnel_id):
+        """
+        Configure ingress routes for the device tunnel
+        Creates a config file for cloudflared
+        """
+        import yaml
+        
+        # Create config file for this tunnel
+        config_dir = Path.home() / '.cloudflared'
+        config_dir.mkdir(exist_ok=True)
+        config_file = config_dir / f'config-{tunnel_id}.yml'
+        
+        config = {
+            "tunnel": tunnel_id,
+            "credentials-file": str(config_dir / f"{tunnel_id}.json"),
+            "ingress": [
+                {
+                    "hostname": f"{self.jupyter_subdomain}.{self.base_domain}",
+                    "service": "http://localhost:8888",
+                    "originRequest": {
+                        "noTLSVerify": True
+                    }
+                },
+                {
+                    "hostname": f"{self.ssh_subdomain}.{self.base_domain}",
+                    "service": "ssh://localhost:22"
+                },
+                {
+                    "service": "http_status:404"
+                }
+            ]
+        }
+        
+        with open(config_file, 'w') as f:
+            yaml.dump(config, f)
+        
+        print(f"✅ Created tunnel config: {config_file}")
+        self.tunnel_config_file = config_file
+    
+    def _save_tunnel_credentials(self, tunnel_info):
+        """
+        Save tunnel credentials locally for this device
+        Credentials must be base64 encoded for cloudflared
+        """
+        import base64
+        import json
+        
+        creds_dir = Path.home() / '.cloudflared'
+        creds_dir.mkdir(exist_ok=True)
+        
+        creds_file = creds_dir / f"{tunnel_info['id']}.json"
+        
+        # Get the secret - it should be hex string
+        secret_hex = tunnel_info.get('tunnel_secret') or tunnel_info.get('secret')
+        if secret_hex:
+            # Convert hex to bytes then to base64
+            secret_bytes = bytes.fromhex(secret_hex)
+            secret_b64 = base64.b64encode(secret_bytes).decode('ascii')
+        else:
+            print("⚠️  No tunnel secret found")
+            return None
+        
+        credentials = {
+            "AccountTag": self.account_id,
+            "TunnelSecret": secret_b64,  # Must be base64!
+            "TunnelID": tunnel_info['id']
+        }
+        
+        with open(creds_file, 'w') as f:
+            json.dump(credentials, f, indent=2)
+        
+        print(f"✅ Saved tunnel credentials: {creds_file}")
+        return creds_file
+    
+    def start_tunnel_with_token(self):
+        """
+        Start tunnel using API-created tunnel with UUID
+        """
+        try:
+            print("🚀 Starting Cloudflare tunnel...")
+            
+            # Ensure cloudflared is available
+            cloudflared_path = self._ensure_cloudflared()
+            if not cloudflared_path:
+                raise RuntimeError("Failed to obtain cloudflared binary")
+            
+            # Create a new unique tunnel
+            device_tunnel = self.create_device_tunnel()
+            
+            if not device_tunnel:
+                print("❌ Could not create device tunnel")
+                return None
+            
+            tunnel_id = device_tunnel['id']
+            tunnel_name = device_tunnel['name']
+            
+            print(f"🚇 Starting tunnel: {tunnel_name} ({tunnel_id})")
+            
+            # Check credentials file exists
+            creds_file = Path.home() / '.cloudflared' / f"{tunnel_id}.json"
+            config_file = Path.home() / '.cloudflared' / f'config-{tunnel_id}.yml'
+            
+            if not creds_file.exists():
+                print("❌ Error: No credentials file found for newly created tunnel")
+                return None
+            
+            # Use config file if it exists, otherwise use credentials file
+            if config_file.exists():
+                cmd = [
+                    cloudflared_path,
+                    "tunnel",
+                    "--no-autoupdate",
+                    "--config", str(config_file),
+                    "run"
+                ]
+            else:
+                cmd = [
+                    cloudflared_path,
+                    "tunnel",
+                    "--no-autoupdate",
+                    "--credentials-file", str(creds_file),
+                    "run",
+                    tunnel_id
+                ]
+            
+            # Start tunnel process
+            self.tunnel_process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1
+            )
+            
+            print("⏳ Waiting for tunnel to connect...")
+            time.sleep(5)
+            
+            if self.tunnel_process.poll() is None:
+                print("✅ Tunnel is running!")
+                print(f"📌 Device ID: {self.clean_device_id}")
+                print(f"📌 Jupyter URL: {self.jupyter_url}")
+                print(f"📌 SSH hostname: {self.ssh_hostname}")
+                print(f"📌 SSH command: ssh -o ProxyCommand='cloudflared access ssh --hostname {self.ssh_hostname}' user@localhost")
+                return self.tunnel_process
+            else:
+                output = self.tunnel_process.stdout.read() if self.tunnel_process.stdout else ""
+                print(f"❌ Tunnel failed to start: {output}")
+                return None
+                
+        except Exception as e:
+            print(f"❌ Error starting tunnel: {e}")
+            return None
+    
+    def setup(self, jupyter_port=8888):
+        """
+        Setup and start tunnel (maintains compatibility)
+        """
+        return self.start_tunnel_with_token()
+    
+    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()
+            try:
+                self.tunnel_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.tunnel_process.kill()
+            print("Tunnel stopped")
+    
+    def _ensure_cloudflared(self):
+        """
+        Ensure cloudflared binary is available
+        """
+        print("🔍 Checking for cloudflared binary...")
+        
+        # Try binary manager first
+        if self.binary_manager:
+            try:
+                path = self.binary_manager.get_binary_path()
+                print(f"✅ Using cloudflared from binary manager: {path}")
+                return path
+            except Exception as e:
+                print(f"⚠️  Binary manager failed: {e}")
+        
+        # Fallback to system cloudflared
+        try:
+            result = subprocess.run(['which', 'cloudflared'], capture_output=True, text=True)
+            if result.returncode == 0:
+                path = result.stdout.strip()
+                print(f"✅ Found system cloudflared: {path}")
+                return path
+        except:
+            pass
+        
+        print("❌ cloudflared not found")
+        return None

unitlab-2.3.20/src/unitlab/cloudflare_api_tunnel.py → unitlab-2.3.23/src/unitlab/cloudflare_api_tunnel_backup.py

@@ -206,75 +206,47 @@ class CloudflareAPITunnel:
             print("   Assuming routes are configured in dashboard.")
             return True
 
-    def create_device_tunnel(self, retry_on_fail=True):
+    def create_device_tunnel(self):
         """
-        Create a unique tunnel for this device if it doesn't exist
+        Create a unique tunnel for this device
+        Each tunnel gets a unique UUID to avoid conflicts
         """
-        tunnel_name = f"device-{self.clean_device_id}"
-        print(f"🔍 Checking for tunnel: {tunnel_name}")
+        import uuid
+        # Always use a unique name with UUID
+        unique_id = str(uuid.uuid4())[:8]
+        tunnel_name = f"device-{self.clean_device_id}-{unique_id}"
+        # Since we use UUID, no need to check - just create new tunnel
+        create_url = f"{self.api_base}/accounts/{self.account_id}/tunnels"
+        # Generate secret first
+        tunnel_secret = os.urandom(32).hex()
+        
+        create_data = {
+            "name": tunnel_name,
+            "tunnel_secret": tunnel_secret
+        }
         
-        # Check if tunnel already exists
-        list_url = f"{self.api_base}/accounts/{self.account_id}/tunnels"
-        response = requests.get(list_url, headers=self.headers)
+        create_response = requests.post(create_url, headers=self.headers, json=create_data)
         
-        if response.status_code == 200:
-            tunnels = response.json().get('result', [])
-            existing_tunnel = None
+        if create_response.status_code in [200, 201]:
+            tunnel = create_response.json()['result']
+            print(f"✅ Created tunnel: {tunnel_name}")
             
-            for tunnel in tunnels:
-                if tunnel['name'] == tunnel_name:
-                    existing_tunnel = tunnel
-                    print(f"✅ Found existing tunnel: {tunnel_name}")
-                    break
+            # Add the secret to the tunnel info (API doesn't return it)
+            tunnel['tunnel_secret'] = tunnel_secret
             
-            if not existing_tunnel:
-                # Create new tunnel
-                print(f"📦 Creating new tunnel: {tunnel_name}")
-                create_url = f"{self.api_base}/accounts/{self.account_id}/tunnels"
-                # Generate secret first
-                tunnel_secret = os.urandom(32).hex()
-                
-                create_data = {
-                    "name": tunnel_name,
-                    "tunnel_secret": tunnel_secret
-                }
-                
-                create_response = requests.post(create_url, headers=self.headers, json=create_data)
-                
-                if create_response.status_code in [200, 201]:
-                    existing_tunnel = create_response.json()['result']
-                    print(f"✅ Created tunnel: {tunnel_name}")
-                    
-                    # Add the secret to the tunnel info (API doesn't return it)
-                    existing_tunnel['tunnel_secret'] = tunnel_secret
-                    
-                    # Save credentials for this tunnel
-                    self._save_tunnel_credentials(existing_tunnel)
-                    
-                    # Configure tunnel routes
-                    self._configure_tunnel_routes(existing_tunnel['id'])
-                    
-                    # Create DNS records for this device
-                    self.create_dns_records()
-                else:
-                    print(f"❌ Failed to create tunnel: {create_response.text}")
-                    return None
-            else:
-                # Tunnel exists - but we need to ensure it can be used
-                print(f"♻️  Found existing tunnel, setting up for use")
-                
-                # Store tunnel info for later use
-                existing_tunnel['needs_token'] = True  # Mark that we'll need to use token
-                
-                # Configure tunnel routes (creates config file)
-                self._configure_tunnel_routes(existing_tunnel['id'])
-                
-                # Ensure DNS records exist
-                self.create_dns_records()
+            # Save credentials for this tunnel
+            self._save_tunnel_credentials(tunnel)
             
-            return existing_tunnel
-        
-        return None
+            # Configure tunnel routes
+            self._configure_tunnel_routes(tunnel['id'])
+            
+            # Create DNS records for this device
+            self.create_dns_records()
+            
+            return tunnel
+        else:
+            print(f"❌ Failed to create tunnel: {create_response.text}")
+            return None
     
     def _configure_tunnel_routes(self, tunnel_id):
         """
@@ -363,7 +335,7 @@ class CloudflareAPITunnel:
             if not cloudflared_path:
                 raise RuntimeError("Failed to obtain cloudflared binary")
             
-            # Create or get existing tunnel for this device
+            # Always create a new unique tunnel with UUID
             device_tunnel = self.create_device_tunnel()
             
             # Now set up DNS and routes via API after tunnel is created/found
@@ -372,21 +344,6 @@ class CloudflareAPITunnel:
                 self.create_dns_records()
                 self.update_tunnel_config()
             
-            # Check if we need to recreate the tunnel
-            if device_tunnel and device_tunnel.get('needs_recreation'):
-                print("🔄 Recreating tunnel due to access issues...")
-                # Delete the old tunnel
-                tunnel_id = device_tunnel['id']
-                delete_url = f"{self.api_base}/accounts/{self.account_id}/tunnels/{tunnel_id}"
-                delete_response = requests.delete(delete_url, headers=self.headers)
-                if delete_response.status_code in [200, 204, 404]:
-                    print(f"   ✅ Deleted old tunnel")
-                    # Try creating a new one with a timestamp suffix
-                    self.clean_device_id = f"{self.device_id.replace(' ', '').replace('-', '').replace('.', '').replace('_', '')[:24]}-{int(time.time())}"
-                    device_tunnel = self.create_device_tunnel(retry_on_fail=False)
-                    if device_tunnel:
-                        print(f"   ✅ Created new tunnel")
-            
             if not device_tunnel:
                 print("❌ Could not create/find device tunnel")
                 # Fallback to shared tunnel if API fails
@@ -411,21 +368,12 @@ class CloudflareAPITunnel:
                 config_file = Path.home() / '.cloudflared' / f'config-{tunnel_id}.yml'
                 cmd = None  # Initialize cmd
                 
-                if not creds_file.exists() or device_tunnel.get('needs_token'):
-                    # Try to recreate credentials from stored secret
-                    if device_tunnel.get('tunnel_secret'):
-                        self._save_tunnel_credentials(device_tunnel)
-                        # Continue to use credentials below
-                    else:
-                        print("⚠️  No stored credentials, requesting tunnel token...")
-                        # Get token for this tunnel
-                        token_url = f"{self.api_base}/accounts/{self.account_id}/tunnels/{tunnel_id}/token"
-                        print(f"   Token URL: {token_url}")
-                        
-                        token_response = requests.get(token_url, headers=self.headers)
-                        print(f"   Token response status: {token_response.status_code}")
-                        
-                        if token_response.status_code == 200:
+                # Since we always create new tunnels, credentials should exist
+                if not creds_file.exists():
+                    print("❌ Error: No credentials file found for newly created tunnel")
+                    return None
+                
+                # Use credentials to run tunnel
                             result = token_response.json()
                             if 'result' in result:
                                 token = result['result']
@@ -463,11 +411,58 @@ class CloudflareAPITunnel:
                             
                             # If 404, tunnel doesn't exist or we don't have access
                             if token_response.status_code == 404:
-                                print(f"🔄 Tunnel not accessible (404), will recreate...")
-                                # Mark for recreation and continue
-                                device_tunnel['needs_recreation'] = True
-                                # Set cmd to None to skip the rest of this block
-                                cmd = None
+                                print(f"🔄 Tunnel not accessible (404), need to recreate...")
+                                # Delete the old tunnel immediately
+                                delete_url = f"{self.api_base}/accounts/{self.account_id}/tunnels/{tunnel_id}"
+                                delete_response = requests.delete(delete_url, headers=self.headers)
+                                if delete_response.status_code in [200, 204, 404]:
+                                    print(f"   ✅ Deleted old tunnel")
+                                
+                                # Create a new tunnel with timestamp
+                                import uuid
+                                # Use a random suffix to ensure uniqueness
+                                random_suffix = str(uuid.uuid4())[:8]
+                                self.clean_device_id = f"{self.device_id.replace(' ', '').replace('-', '').replace('.', '').replace('_', '')[:16]}-{random_suffix}"
+                                print(f"   Creating new tunnel with ID: {self.clean_device_id}")
+                                
+                                new_tunnel = self.create_device_tunnel(force_new=False)
+                                
+                                if new_tunnel and new_tunnel.get('tunnel_secret'):
+                                    print(f"   ✅ Created new tunnel: {new_tunnel['name']}")
+                                    # Use the new tunnel directly - update references
+                                    device_tunnel = new_tunnel
+                                    tunnel_id = new_tunnel['id']
+                                    tunnel_name = new_tunnel['name']
+                                    
+                                    # Check if credentials were saved
+                                    creds_file = Path.home() / '.cloudflared' / f"{tunnel_id}.json"
+                                    if creds_file.exists():
+                                        print(f"   ✅ Credentials saved for new tunnel")
+                                        # Set up command to run with credentials
+                                        config_file = Path.home() / '.cloudflared' / f'config-{tunnel_id}.yml'
+                                        if config_file.exists():
+                                            cmd = [
+                                                cloudflared_path,
+                                                "tunnel",
+                                                "--no-autoupdate",
+                                                "--config", str(config_file),
+                                                "run"
+                                            ]
+                                        else:
+                                            cmd = [
+                                                cloudflared_path,
+                                                "tunnel",
+                                                "--no-autoupdate",
+                                                "--credentials-file", str(creds_file),
+                                                "run",
+                                                tunnel_id
+                                            ]
+                                    else:
+                                        print(f"   ❌ No credentials for new tunnel, cannot proceed")
+                                        return None
+                                else:
+                                    print(f"   ❌ Failed to create replacement tunnel")
+                                    return None
                             else:
                                 print(f"   ℹ️  Token endpoint returned {token_response.status_code}")
                                 print(f"   This might mean the tunnel needs to be recreated manually")
@@ -521,12 +516,8 @@ class CloudflareAPITunnel:
                     print(f"❌ Tunnel failed to start: {output}")
                     return None
             else:
-                # If no cmd, it means we need to handle recreation or other error
-                if device_tunnel and device_tunnel.get('needs_recreation'):
-                    # The recreation happens above before this point
-                    print("❌ Failed to start tunnel after recreation attempt")
-                else:
-                    print("❌ No valid command to start tunnel")
+                # If no cmd, something went wrong
+                print("❌ No valid command to start tunnel")
                 return None
                 
         except Exception as e:

{unitlab-2.3.20 → unitlab-2.3.23/src/unitlab.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unitlab
-Version: 2.3.20
+Version: 2.3.23
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai

{unitlab-2.3.20 → unitlab-2.3.23}/src/unitlab.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/unitlab/__main__.py
 src/unitlab/binary_manager.py
 src/unitlab/client.py
 src/unitlab/cloudflare_api_tunnel.py
+src/unitlab/cloudflare_api_tunnel_backup.py
 src/unitlab/exceptions.py
 src/unitlab/main.py
 src/unitlab/tunnel_config.py