unitlab 2.3.28__py3-none-any.whl → 2.3.29__py3-none-any.whl

unitlab/api_tunnel.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""
+Simple API-based Dynamic Tunnel - Each device gets deviceid.1scan.uz
+"""
+
+import subprocess
+import requests
+import json
+import time
+import os
+
+class APITunnel:
+    def __init__(self, device_id=None):
+        """Initialize with device ID"""
+        # Hardcoded Cloudflare credentials for simplicity
+        self.cf_email = "muminovbobur93@gmail.com"
+        self.cf_api_key = "1ae47782b5e2e639fb088ee73e17b74db4b4e"  # Global API Key
+        self.cf_account_id = "c91192ae20a5d43f65e087550d8dc89b"
+        self.cf_zone_id = "06ebea0ee0b228c186f97fe9a0a7c83e"  # for 1scan.uz
+        
+        # Clean device ID for subdomain
+        if device_id:
+            self.device_id = device_id.replace('-', '').replace('_', '').replace('.', '').lower()[:20]
+        else:
+            import uuid
+            self.device_id = str(uuid.uuid4())[:8]
+        
+        self.tunnel_name = "agent-{}".format(self.device_id)
+        self.subdomain = self.device_id
+        self.jupyter_url = "https://{}.1scan.uz".format(self.subdomain)
+        
+        self.tunnel_id = None
+        self.tunnel_token = None
+        self.jupyter_process = None
+        self.tunnel_process = None
+    
+    def create_tunnel_via_cli(self):
+        """Create tunnel using cloudflared CLI (simpler than API)"""
+        print("🔧 Creating tunnel: {}...".format(self.tunnel_name))
+        
+        cloudflared = self.get_cloudflared_path()
+        
+        # Login with cert (one-time if not logged in)
+        # This uses the cert.pem file if it exists
+        cert_path = os.path.expanduser("~/.cloudflared/cert.pem")
+        if not os.path.exists(cert_path):
+            print("📝 First time setup - logging in to Cloudflare...")
+            # Use service token instead of interactive login
+            # Or use the API to create tunnel
+        
+        # Create tunnel using CLI
+        cmd = [cloudflared, "tunnel", "create", self.tunnel_name]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if result.returncode == 0:
+            # Extract tunnel ID from output
+            import re
+            match = re.search(r'Created tunnel .* with id ([a-f0-9-]+)', result.stdout)
+            if match:
+                self.tunnel_id = match.group(1)
+                print("✅ Tunnel created: {}".format(self.tunnel_id))
+                
+                # Get the tunnel token
+                token_cmd = [cloudflared, "tunnel", "token", self.tunnel_name]
+                token_result = subprocess.run(token_cmd, capture_output=True, text=True)
+                if token_result.returncode == 0:
+                    self.tunnel_token = token_result.stdout.strip()
+                    return True
+        
+        print("⚠️  Could not create tunnel via CLI, using quick tunnel instead")
+        return False
+    
+    def create_dns_record(self):
+        """Add DNS record for subdomain"""
+        if not self.tunnel_id:
+            return False
+            
+        print("🔧 Creating DNS: {}.1scan.uz...".format(self.subdomain))
+        
+        url = "https://api.cloudflare.com/client/v4/zones/{}/dns_records".format(self.cf_zone_id)
+        
+        headers = {
+            "X-Auth-Email": self.cf_email,
+            "X-Auth-Key": self.cf_api_key,
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "type": "CNAME",
+            "name": self.subdomain,
+            "content": "{}.cfargotunnel.com".format(self.tunnel_id),
+            "proxied": True
+        }
+        
+        response = requests.post(url, headers=headers, json=data)
+        if response.status_code in [200, 409]:  # 409 = already exists
+            print("✅ DNS configured")
+            return True
+        
+        print("⚠️  DNS setup failed: {}".format(response.text[:100]))
+        return False
+    
+    def get_cloudflared_path(self):
+        """Get or download cloudflared"""
+        import shutil
+        if shutil.which("cloudflared"):
+            return "cloudflared"
+        
+        local_bin = os.path.expanduser("~/.local/bin/cloudflared")
+        if os.path.exists(local_bin):
+            return local_bin
+        
+        # Download
+        print("📦 Downloading cloudflared...")
+        import platform
+        system = platform.system().lower()
+        arch = "amd64" if "x86" in platform.machine() else "arm64"
+        url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{}".format(arch)
+        
+        os.makedirs(os.path.dirname(local_bin), exist_ok=True)
+        subprocess.run("curl -L {} -o {}".format(url, local_bin), shell=True, capture_output=True)
+        subprocess.run("chmod +x {}".format(local_bin), shell=True)
+        return local_bin
+    
+    def start_jupyter(self):
+        """Start Jupyter"""
+        print("🚀 Starting Jupyter...")
+        
+        cmd = [
+            "jupyter", "notebook",
+            "--port", "8888",
+            "--no-browser",
+            "--ip", "0.0.0.0",
+            "--NotebookApp.token=''",
+            "--NotebookApp.password=''"
+        ]
+        
+        self.jupyter_process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        
+        time.sleep(3)
+        print("✅ Jupyter started")
+        return True
+    
+    def start_tunnel(self):
+        """Start tunnel - try with token first, fallback to quick tunnel"""
+        cloudflared = self.get_cloudflared_path()
+        
+        if self.tunnel_token:
+            # Use token-based tunnel
+            print("🔧 Starting tunnel with token...")
+            cmd = [cloudflared, "tunnel", "run", "--token", self.tunnel_token]
+        elif self.tunnel_id:
+            # Use tunnel ID
+            print("🔧 Starting tunnel with ID...")
+            cmd = [cloudflared, "tunnel", "run", "--url", "http://localhost:8888", self.tunnel_id]
+        else:
+            # Fallback to quick tunnel
+            print("🔧 Starting quick tunnel (random URL)...")
+            cmd = [cloudflared, "tunnel", "--url", "http://localhost:8888"]
+            self.jupyter_url = "Check terminal output for URL"
+        
+        self.tunnel_process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        
+        time.sleep(5)
+        print("✅ Tunnel running")
+        return True
+    
+    def start(self):
+        """Main entry point"""
+        try:
+            print("="*50)
+            print("🌐 API-Based Dynamic Tunnel")
+            print("Device: {}".format(self.device_id))
+            print("="*50)
+            
+            # Try to create named tunnel
+            tunnel_created = self.create_tunnel_via_cli()
+            
+            if tunnel_created:
+                # Add DNS record
+                self.create_dns_record()
+            
+            # Start services
+            self.start_jupyter()
+            self.start_tunnel()
+            
+            print("\n" + "="*50)
+            print("🎉 SUCCESS!")
+            if tunnel_created:
+                print("📍 Your permanent URL: {}".format(self.jupyter_url))
+            else:
+                print("📍 Using quick tunnel - check output for URL")
+            print("="*50)
+            
+            return True
+            
+        except Exception as e:
+            print("❌ Error: {}".format(e))
+            self.stop()
+            return False
+    
+    def stop(self):
+        """Stop everything"""
+        if self.jupyter_process:
+            self.jupyter_process.terminate()
+        if self.tunnel_process:
+            self.tunnel_process.terminate()
+    
+    def run(self):
+        """Run and keep alive"""
+        try:
+            if self.start():
+                print("\nPress Ctrl+C to stop...")
+                while True:
+                    time.sleep(1)
+        except KeyboardInterrupt:
+            print("\n⏹️  Shutting down...")
+            self.stop()
+
+
+def main():
+    """Test the API tunnel"""
+    import platform
+    import uuid
+    
+    hostname = platform.node().replace('.', '-')[:20]
+    device_id = "{}-{}".format(hostname, str(uuid.uuid4())[:8])
+    
+    tunnel = APITunnel(device_id=device_id)
+    tunnel.run()
+
+
+if __name__ == "__main__":
+    main()

unitlab/auto_tunnel.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""
+Automatic Tunnel Creation - Simplest approach using cloudflared's built-in quick tunnel
+No API tokens needed!
+"""
+
+import subprocess
+import time
+import re
+import os
+
+class AutoTunnel:
+    def __init__(self, device_id=None):
+        """
+        Initialize auto tunnel - no credentials needed!
+        """
+        self.device_id = device_id or "device"
+        self.jupyter_process = None
+        self.tunnel_process = None
+        self.tunnel_url = None
+        
+    def get_cloudflared_path(self):
+        """Get or download cloudflared binary"""
+        import platform
+        
+        # Check if exists in system
+        import shutil
+        if shutil.which("cloudflared"):
+            return "cloudflared"
+        
+        # Check local
+        local_bin = os.path.expanduser("~/.local/bin/cloudflared")
+        if os.path.exists(local_bin):
+            return local_bin
+        
+        # Download it
+        print("📦 Downloading cloudflared...")
+        system = platform.system().lower()
+        if system == "linux":
+            arch = "amd64" if "x86" in platform.machine() else "arm64"
+            url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{}".format(arch)
+            
+            os.makedirs(os.path.expanduser("~/.local/bin"), exist_ok=True)
+            subprocess.run("curl -L {} -o {}".format(url, local_bin), shell=True, capture_output=True)
+            subprocess.run("chmod +x {}".format(local_bin), shell=True)
+            print("✅ cloudflared downloaded")
+            return local_bin
+        
+        return "cloudflared"
+    
+    def start_jupyter(self):
+        """Start Jupyter notebook"""
+        print("🚀 Starting Jupyter on port 8888...")
+        
+        cmd = [
+            "jupyter", "notebook",
+            "--port", "8888",
+            "--no-browser",
+            "--ip", "0.0.0.0",
+            "--NotebookApp.token=''",
+            "--NotebookApp.password=''",
+            "--NotebookApp.allow_origin='*'"
+        ]
+        
+        self.jupyter_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        time.sleep(3)
+        print("✅ Jupyter started")
+        return True
+    
+    def start_tunnel(self):
+        """Start tunnel using cloudflared quick tunnel - no auth needed!"""
+        print("🔧 Starting automatic tunnel (no credentials needed)...")
+        
+        cloudflared = self.get_cloudflared_path()
+        
+        # Use cloudflared's quick tunnel feature - generates random URL
+        cmd = [
+            cloudflared,
+            "tunnel",
+            "--url", "http://localhost:8888"
+        ]
+        
+        self.tunnel_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1
+        )
+        
+        # Read output to get the tunnel URL
+        print("⏳ Waiting for tunnel URL...")
+        for _ in range(30):  # Wait up to 30 seconds
+            line = self.tunnel_process.stdout.readline()
+            if line:
+                # Look for the tunnel URL in output
+                match = re.search(r'https://[a-zA-Z0-9-]+\.trycloudflare\.com', line)
+                if match:
+                    self.tunnel_url = match.group(0)
+                    print("✅ Tunnel created: {}".format(self.tunnel_url))
+                    return True
+            time.sleep(1)
+        
+        print("❌ Failed to get tunnel URL")
+        return False
+    
+    def start(self):
+        """Start everything - super simple!"""
+        try:
+            print("="*50)
+            print("🌐 Automatic Cloudflare Tunnel (No Auth Needed!)")
+            print("Device: {}".format(self.device_id))
+            print("="*50)
+            
+            # 1. Start Jupyter
+            if not self.start_jupyter():
+                raise Exception("Failed to start Jupyter")
+            
+            # 2. Start tunnel (automatic, no credentials)
+            if not self.start_tunnel():
+                raise Exception("Failed to start tunnel")
+            
+            print("\n" + "="*50)
+            print("🎉 SUCCESS! Your Jupyter is accessible at:")
+            print("   {}".format(self.tunnel_url))
+            print("="*50)
+            print("\n⚠️  Note: This URL is temporary and random")
+            print("For persistent URLs, use Cloudflare API approach")
+            
+            return True
+            
+        except Exception as e:
+            print("❌ Error: {}".format(e))
+            self.stop()
+            return False
+    
+    def stop(self):
+        """Stop everything"""
+        if self.jupyter_process:
+            self.jupyter_process.terminate()
+        if self.tunnel_process:
+            self.tunnel_process.terminate()
+    
+    def run(self):
+        """Run and keep alive"""
+        try:
+            if self.start():
+                print("\nPress Ctrl+C to stop...")
+                while True:
+                    time.sleep(1)
+        except KeyboardInterrupt:
+            print("\n⏹️  Shutting down...")
+            self.stop()
+            print("👋 Goodbye!")
+
+
+def main():
+    """Test automatic tunnel"""
+    import platform
+    device_id = platform.node()
+    
+    print("Starting auto tunnel for: {}".format(device_id))
+    
+    tunnel = AutoTunnel(device_id=device_id)
+    tunnel.run()
+
+
+if __name__ == "__main__":
+    main()

unitlab/client.py

@@ -281,12 +281,26 @@ class UnitlabClient:
         self.device_id = device_id
         self.base_domain = base_domain
         
-        # Use the simple hardcoded tunnel approach
-        logger.info("Using simple hardcoded Cloudflare tunnel")
-        self.tunnel_manager = SimpleTunnel(device_id=self.device_id)
-        # SimpleTunnel generates the URL internally based on device_id
-        self.jupyter_url = self.tunnel_manager.jupyter_url
-        self.ssh_url = self.jupyter_url  # Same URL for both services
+        # Use persistent tunnel with API (each device gets deviceid.1scan.uz)
+        try:
+            from .persistent_tunnel import PersistentTunnel
+            logger.info("Using Persistent Tunnel with Cloudflare API")
+            self.tunnel_manager = PersistentTunnel(device_id=self.device_id)
+            # URLs will be set after tunnel starts
+            self.jupyter_url = self.tunnel_manager.jupyter_url
+            self.ssh_url = self.jupyter_url
+        except ImportError as e:
+            logger.warning(f"Could not import PersistentTunnel: {e}")
+            # Fallback to easy tunnel
+            try:
+                from .easy_tunnel import EasyTunnelAdapter
+                logger.info("Using Easy Dynamic Tunnel (random URL)")
+                self.tunnel_manager = EasyTunnelAdapter(device_id=self.device_id)
+                self.jupyter_url = None
+                self.ssh_url = None
+            except ImportError:
+                logger.error("No tunnel implementation available!")
+                raise
         
         # Setup signal handlers
         signal.signal(signal.SIGINT, self._handle_shutdown)
@@ -392,16 +406,24 @@ class UnitlabClient:
             
             logger.info("Setting up Cloudflare tunnel...")
             
-            # SimpleTunnel handles both Jupyter and tunnel startup internally
-            # It doesn't need the jupyter_port parameter since it starts its own Jupyter
+            # Both SimpleTunnel and AutoTunnel handle Jupyter internally
             if self.tunnel_manager.start():
                 # Store the processes for monitoring
                 self.jupyter_proc = self.tunnel_manager.jupyter_process
                 self.tunnel_proc = self.tunnel_manager.tunnel_process
-                self.jupyter_port = "8888"  # SimpleTunnel uses fixed port
+                self.jupyter_port = "8888"  # Both use fixed port
+                
+                # Get the URL (AutoTunnel generates it dynamically)
+                if hasattr(self.tunnel_manager, 'tunnel_url') and self.tunnel_manager.tunnel_url:
+                    self.jupyter_url = self.tunnel_manager.tunnel_url
+                    self.ssh_url = self.tunnel_manager.tunnel_url
+                elif hasattr(self.tunnel_manager, 'jupyter_url'):
+                    self.jupyter_url = self.tunnel_manager.jupyter_url
+                    self.ssh_url = self.tunnel_manager.jupyter_url
                 
                 # The tunnel is now running
                 logger.info("✅ Tunnel and Jupyter established")
+                logger.info("URL: {}".format(self.jupyter_url))
                 self.report_services()
                 return True
             else:

unitlab/dynamic_tunnel.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Dynamic Cloudflare Tunnel - Creates a unique tunnel for each device via API
+Simple and automatic!
+"""
+
+import subprocess
+import requests
+import json
+import time
+import os
+
+class DynamicTunnel:
+    def __init__(self, device_id=None):
+        """
+        Initialize with device ID for unique tunnel creation
+        """
+        # Cloudflare API credentials (hardcoded for simplicity)
+        self.cf_api_token = os.getenv("CF_API_TOKEN", "YOUR_API_TOKEN_HERE")
+        self.cf_account_id = os.getenv("CF_ACCOUNT_ID", "c91192ae20a5d43f65e087550d8dc89b")
+        self.cf_zone_id = os.getenv("CF_ZONE_ID", "YOUR_ZONE_ID_HERE")
+        
+        # Domain config
+        self.domain = "1scan.uz"
+        
+        # Generate clean device ID
+        if device_id:
+            self.device_id = device_id.replace('-', '').replace('_', '').replace('.', '').lower()[:20]
+        else:
+            import uuid
+            self.device_id = str(uuid.uuid4())[:8]
+        
+        # Tunnel will be created with this name
+        self.tunnel_name = "agent-{}".format(self.device_id)
+        self.subdomain = self.device_id
+        self.jupyter_url = "https://{}.{}".format(self.subdomain, self.domain)
+        
+        self.tunnel_id = None
+        self.tunnel_token = None
+        self.jupyter_process = None
+        self.tunnel_process = None
+        
+    def create_tunnel(self):
+        """Create a new tunnel via Cloudflare API"""
+        print("🔧 Creating tunnel: {}".format(self.tunnel_name))
+        
+        url = "https://api.cloudflare.com/client/v4/accounts/{}/tunnels".format(self.cf_account_id)
+        
+        headers = {
+            "Authorization": "Bearer {}".format(self.cf_api_token),
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "name": self.tunnel_name,
+            "tunnel_secret": None  # Let Cloudflare generate it
+        }
+        
+        try:
+            response = requests.post(url, headers=headers, json=data)
+            result = response.json()
+            
+            if response.status_code == 200 and result.get("success"):
+                self.tunnel_id = result["result"]["id"]
+                self.tunnel_token = result["result"]["token"]
+                print("✅ Tunnel created: {}".format(self.tunnel_id))
+                return True
+            else:
+                print("❌ Failed to create tunnel: {}".format(result.get("errors", "Unknown error")))
+                return False
+                
+        except Exception as e:
+            print("❌ Error creating tunnel: {}".format(e))
+            return False
+    
+    def create_dns_record(self):
+        """Create DNS record for the tunnel"""
+        print("🔧 Creating DNS record: {}.{}".format(self.subdomain, self.domain))
+        
+        url = "https://api.cloudflare.com/client/v4/zones/{}/dns_records".format(self.cf_zone_id)
+        
+        headers = {
+            "Authorization": "Bearer {}".format(self.cf_api_token),
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "type": "CNAME",
+            "name": self.subdomain,
+            "content": "{}.cfargotunnel.com".format(self.tunnel_id),
+            "proxied": True
+        }
+        
+        try:
+            response = requests.post(url, headers=headers, json=data)
+            result = response.json()
+            
+            if response.status_code == 200 and result.get("success"):
+                print("✅ DNS record created")
+                return True
+            else:
+                # Might already exist, try to update
+                print("⚠️  DNS might already exist, continuing...")
+                return True
+                
+        except Exception as e:
+            print("⚠️  DNS error (continuing): {}".format(e))
+            return True  # Continue anyway
+    
+    def get_cloudflared_path(self):
+        """Get or download cloudflared binary"""
+        import platform
+        
+        # Check if exists
+        try:
+            import shutil
+            if shutil.which("cloudflared"):
+                return "cloudflared"
+        except:
+            pass
+        
+        # Check local
+        local_bin = os.path.expanduser("~/.local/bin/cloudflared")
+        if os.path.exists(local_bin):
+            return local_bin
+        
+        # Download
+        print("📦 Downloading cloudflared...")
+        system = platform.system().lower()
+        if system == "linux":
+            arch = "amd64" if "x86" in platform.machine() else "arm64"
+            url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{}".format(arch)
+            
+            os.makedirs(os.path.expanduser("~/.local/bin"), exist_ok=True)
+            subprocess.run("curl -L {} -o {}".format(url, local_bin), shell=True)
+            subprocess.run("chmod +x {}".format(local_bin), shell=True)
+            print("✅ cloudflared downloaded")
+            return local_bin
+        
+        return "cloudflared"
+    
+    def start_jupyter(self):
+        """Start Jupyter notebook"""
+        print("🚀 Starting Jupyter...")
+        
+        cmd = [
+            "jupyter", "notebook",
+            "--port", "8888",
+            "--no-browser",
+            "--ip", "0.0.0.0",
+            "--NotebookApp.token=''",
+            "--NotebookApp.password=''",
+            "--NotebookApp.allow_origin='*'"
+        ]
+        
+        self.jupyter_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        time.sleep(3)
+        print("✅ Jupyter started on port 8888")
+        return True
+    
+    def start_tunnel(self):
+        """Start the tunnel using the token"""
+        print("🔧 Starting tunnel...")
+        
+        cloudflared = self.get_cloudflared_path()
+        
+        # Use the token to run tunnel
+        cmd = [
+            cloudflared,
+            "tunnel",
+            "run",
+            "--token", self.tunnel_token
+        ]
+        
+        self.tunnel_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        time.sleep(5)
+        print("✅ Tunnel running at {}".format(self.jupyter_url))
+        return True
+    
+    def start(self):
+        """Main entry point - creates everything dynamically"""
+        try:
+            print("="*50)
+            print("🌐 Dynamic Cloudflare Tunnel")
+            print("Device ID: {}".format(self.device_id))
+            print("="*50)
+            
+            # 1. Create tunnel via API
+            if not self.create_tunnel():
+                raise Exception("Failed to create tunnel")
+            
+            # 2. Create DNS record
+            self.create_dns_record()
+            
+            # 3. Start Jupyter
+            if not self.start_jupyter():
+                raise Exception("Failed to start Jupyter")
+            
+            # 4. Start tunnel
+            if not self.start_tunnel():
+                raise Exception("Failed to start tunnel")
+            
+            print("\n" + "="*50)
+            print("🎉 SUCCESS! Your unique tunnel is ready:")
+            print("   {}".format(self.jupyter_url))
+            print("   Tunnel ID: {}".format(self.tunnel_id))
+            print("="*50)
+            
+            return True
+            
+        except Exception as e:
+            print("❌ Error: {}".format(e))
+            self.cleanup()
+            return False
+    
+    def cleanup(self):
+        """Clean up resources"""
+        if self.jupyter_process:
+            self.jupyter_process.terminate()
+        if self.tunnel_process:
+            self.tunnel_process.terminate()
+        
+        # Optionally delete tunnel via API
+        if self.tunnel_id and self.cf_api_token != "YOUR_API_TOKEN_HERE":
+            try:
+                url = "https://api.cloudflare.com/client/v4/accounts/{}/tunnels/{}".format(
+                    self.cf_account_id, self.tunnel_id
+                )
+                headers = {"Authorization": "Bearer {}".format(self.cf_api_token)}
+                requests.delete(url, headers=headers)
+                print("🗑️  Tunnel deleted")
+            except:
+                pass
+    
+    def run(self):
+        """Run and keep alive"""
+        try:
+            if self.start():
+                while True:
+                    time.sleep(1)
+        except KeyboardInterrupt:
+            print("\n⏹️  Shutting down...")
+            self.cleanup()
+            print("👋 Goodbye!")
+
+
+def main():
+    """Test dynamic tunnel creation"""
+    import platform
+    import uuid
+    
+    hostname = platform.node().replace('.', '-')[:20]
+    device_id = "{}-{}".format(hostname, str(uuid.uuid4())[:8])
+    
+    print("Creating dynamic tunnel for: {}".format(device_id))
+    
+    tunnel = DynamicTunnel(device_id=device_id)
+    tunnel.run()
+
+
+if __name__ == "__main__":
+    main()

unitlab/easy_tunnel.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+Easiest Dynamic Tunnel - Each device gets its own tunnel at deviceid.1scan.uz
+Using Cloudflare API with service token
+"""
+
+import subprocess
+import time
+import os
+import requests
+import json
+
+class EasyTunnel:
+    def __init__(self, device_id=None):
+        """Initialize with device ID"""
+        # Generate clean device ID
+        if device_id:
+            self.device_id = device_id.replace('-', '').replace('_', '').replace('.', '').lower()[:20]
+        else:
+            import uuid
+            self.device_id = str(uuid.uuid4())[:8]
+        
+        self.subdomain = self.device_id
+        self.jupyter_url = "https://{}.1scan.uz".format(self.subdomain)
+        
+        # Processes
+        self.jupyter_process = None
+        self.tunnel_process = None
+        
+        # We'll use service tokens (created per tunnel)
+        self.tunnel_token = None
+    
+    def get_cloudflared_path(self):
+        """Get or download cloudflared binary"""
+        import shutil
+        if shutil.which("cloudflared"):
+            return "cloudflared"
+        
+        local_bin = os.path.expanduser("~/.local/bin/cloudflared")
+        if os.path.exists(local_bin):
+            return local_bin
+        
+        # Download it
+        print("📦 Downloading cloudflared...")
+        import platform
+        system = platform.system().lower()
+        if system == "linux":
+            arch = "amd64" if "x86" in platform.machine() else "arm64"
+            url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{}".format(arch)
+            
+            os.makedirs(os.path.dirname(local_bin), exist_ok=True)
+            subprocess.run("curl -L {} -o {}".format(url, local_bin), shell=True, capture_output=True)
+            subprocess.run("chmod +x {}".format(local_bin), shell=True)
+            print("✅ cloudflared downloaded")
+            return local_bin
+        
+        return "cloudflared"
+    
+    def create_quick_tunnel(self):
+        """Use Cloudflare Quick Tunnel - no auth needed, but random URL"""
+        print("🔧 Creating quick tunnel (no auth needed)...")
+        
+        cloudflared = self.get_cloudflared_path()
+        
+        # Quick tunnel command - generates random URL
+        cmd = [
+            cloudflared,
+            "tunnel",
+            "--url", "http://localhost:8888",
+            "--no-tls-verify",
+            "--metrics", "localhost:0"  # Disable metrics
+        ]
+        
+        self.tunnel_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1
+        )
+        
+        # Read output to get URL
+        print("⏳ Getting tunnel URL...")
+        for i in range(30):
+            line = self.tunnel_process.stdout.readline()
+            if line and "trycloudflare.com" in line:
+                # Extract URL from output
+                import re
+                match = re.search(r'https://[a-zA-Z0-9-]+\.trycloudflare\.com', line)
+                if match:
+                    self.jupyter_url = match.group(0)
+                    print("✅ Quick tunnel URL: {}".format(self.jupyter_url))
+                    return True
+            time.sleep(0.5)
+        
+        return False
+    
+    def start_jupyter(self):
+        """Start Jupyter notebook"""
+        print("🚀 Starting Jupyter...")
+        
+        cmd = [
+            "jupyter", "notebook",
+            "--port", "8888",
+            "--no-browser",
+            "--ip", "0.0.0.0",
+            "--NotebookApp.token=''",
+            "--NotebookApp.password=''",
+            "--NotebookApp.allow_origin='*'"
+        ]
+        
+        self.jupyter_process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        time.sleep(3)
+        print("✅ Jupyter started on port 8888")
+        return True
+    
+    def start(self):
+        """Start everything - super simple"""
+        try:
+            print("="*50)
+            print("🌐 Easy Dynamic Tunnel")
+            print("Device ID: {}".format(self.device_id))
+            print("="*50)
+            
+            # 1. Start Jupyter
+            if not self.start_jupyter():
+                raise Exception("Failed to start Jupyter")
+            
+            # 2. Create tunnel (quick tunnel for now)
+            if not self.create_quick_tunnel():
+                raise Exception("Failed to create tunnel")
+            
+            print("\n" + "="*50)
+            print("🎉 SUCCESS! Your Jupyter is accessible at:")
+            print("   {}".format(self.jupyter_url))
+            print("="*50)
+            print("\n📝 Note: For persistent URLs at {}.1scan.uz,".format(self.subdomain))
+            print("   we need Cloudflare API integration")
+            
+            return True
+            
+        except Exception as e:
+            print("❌ Error: {}".format(e))
+            self.stop()
+            return False
+    
+    def stop(self):
+        """Stop everything"""
+        if self.jupyter_process:
+            self.jupyter_process.terminate()
+            self.jupyter_process = None
+        if self.tunnel_process:
+            self.tunnel_process.terminate()
+            self.tunnel_process = None
+    
+    def run(self):
+        """Run and keep alive"""
+        try:
+            if self.start():
+                print("\nPress Ctrl+C to stop...")
+                while True:
+                    time.sleep(1)
+        except KeyboardInterrupt:
+            print("\n⏹️  Shutting down...")
+            self.stop()
+            print("👋 Goodbye!")
+
+
+# For integration with existing client.py
+class EasyTunnelAdapter:
+    """Adapter to make EasyTunnel work with existing client.py interface"""
+    def __init__(self, device_id):
+        self.tunnel = EasyTunnel(device_id)
+        self.jupyter_process = None
+        self.tunnel_process = None
+        self.jupyter_url = None
+    
+    def start(self):
+        """Start method compatible with client.py"""
+        if self.tunnel.start():
+            self.jupyter_process = self.tunnel.jupyter_process
+            self.tunnel_process = self.tunnel.tunnel_process
+            self.jupyter_url = self.tunnel.jupyter_url
+            return True
+        return False
+    
+    def stop(self):
+        """Stop method compatible with client.py"""
+        self.tunnel.stop()
+
+
+def main():
+    """Test the easy tunnel"""
+    import platform
+    import uuid
+    
+    hostname = platform.node().replace('.', '-')[:20]
+    device_id = "{}-{}".format(hostname, str(uuid.uuid4())[:8])
+    
+    tunnel = EasyTunnel(device_id=device_id)
+    tunnel.run()
+
+
+if __name__ == "__main__":
+    main()

unitlab/persistent_tunnel.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+"""
+Persistent Tunnel - Each device gets deviceid.1scan.uz
+Uses Cloudflare API to create named tunnels
+"""
+
+import subprocess
+import requests
+import json
+import time
+import os
+import base64
+
+class PersistentTunnel:
+    def __init__(self, device_id=None):
+        """Initialize with device ID"""
+        
+        # Cloudflare credentials (hardcoded for simplicity)
+        self.cf_email = "uone2323@gmail.com"
+        self.cf_api_key = "1c634bd17ca6ade0eb91966323589fd98c72e"  # Global API Key
+        
+        # Account and Zone IDs
+        self.cf_account_id = "c91192ae20a5d43f65e087550d8dc89b"  # Your account ID
+        self.cf_zone_id = "78182c3883adad79d8f1026851a68176"  # Zone ID for 1scan.uz
+        
+        # Clean device ID for subdomain
+        if device_id:
+            self.device_id = device_id.replace('-', '').replace('_', '').replace('.', '').lower()[:20]
+        else:
+            import uuid
+            self.device_id = str(uuid.uuid4())[:8]
+        
+        self.tunnel_name = "agent-{}".format(self.device_id)
+        self.subdomain = self.device_id
+        self.domain = "1scan.uz"
+        self.jupyter_url = "https://{}.{}".format(self.subdomain, self.domain)
+        
+        self.tunnel_id = None
+        self.tunnel_credentials = None
+        self.jupyter_process = None
+        self.tunnel_process = None
+    
+    def get_zone_id(self):
+        """Get Zone ID for 1scan.uz"""
+        print("🔍 Getting Zone ID for {}...".format(self.domain))
+        
+        url = "https://api.cloudflare.com/client/v4/zones"
+        headers = self._get_headers()
+        params = {"name": self.domain}
+        
+        response = requests.get(url, headers=headers, params=params)
+        if response.status_code == 200:
+            data = response.json()
+            if data["result"]:
+                self.cf_zone_id = data["result"][0]["id"]
+                print("✅ Zone ID: {}".format(self.cf_zone_id))
+                return self.cf_zone_id
+        
+        print("❌ Could not get Zone ID")
+        return None
+    
+    def _get_headers(self):
+        """Get API headers for Global API Key"""
+        return {
+            "X-Auth-Email": self.cf_email,
+            "X-Auth-Key": self.cf_api_key,
+            "Content-Type": "application/json"
+        }
+    
+    def create_tunnel(self):
+        """Create a new tunnel via API"""
+        print("🔧 Creating tunnel: {}...".format(self.tunnel_name))
+        
+        # Generate random tunnel secret (32 bytes)
+        import secrets
+        tunnel_secret = base64.b64encode(secrets.token_bytes(32)).decode()
+        
+        url = "https://api.cloudflare.com/client/v4/accounts/{}/cfd_tunnel".format(self.cf_account_id)
+        headers = self._get_headers()
+        
+        data = {
+            "name": self.tunnel_name,
+            "tunnel_secret": tunnel_secret
+        }
+        
+        response = requests.post(url, headers=headers, json=data)
+        
+        if response.status_code in [200, 201]:
+            result = response.json()["result"]
+            self.tunnel_id = result["id"]
+            
+            # Create credentials JSON
+            self.tunnel_credentials = {
+                "AccountTag": self.cf_account_id,
+                "TunnelSecret": tunnel_secret,
+                "TunnelID": self.tunnel_id
+            }
+            
+            # Save credentials to file
+            cred_file = "/tmp/tunnel-{}.json".format(self.tunnel_id)
+            with open(cred_file, 'w') as f:
+                json.dump(self.tunnel_credentials, f)
+            
+            print("✅ Tunnel created: {}".format(self.tunnel_id))
+            return cred_file
+        else:
+            print("❌ Failed to create tunnel: {}".format(response.text[:200]))
+            return None
+    
+    def create_dns_record(self):
+        """Create DNS CNAME record"""
+        if not self.tunnel_id:
+            return False
+        
+        print("🔧 Creating DNS record: {}.{}...".format(self.subdomain, self.domain))
+        
+        # Get zone ID if we don't have it
+        if self.cf_zone_id == "NEED_ZONE_ID_FOR_1SCAN_UZ":
+            self.get_zone_id()
+        
+        url = "https://api.cloudflare.com/client/v4/zones/{}/dns_records".format(self.cf_zone_id)
+        headers = self._get_headers()
+        
+        data = {
+            "type": "CNAME",
+            "name": self.subdomain,
+            "content": "{}.cfargotunnel.com".format(self.tunnel_id),
+            "proxied": True,
+            "ttl": 1
+        }
+        
+        response = requests.post(url, headers=headers, json=data)
+        
+        if response.status_code in [200, 201]:
+            print("✅ DNS record created")
+            return True
+        elif "already exists" in response.text:
+            print("⚠️  DNS record already exists")
+            return True
+        else:
+            print("❌ Failed to create DNS: {}".format(response.text[:200]))
+            return False
+    
+    def create_tunnel_config(self, cred_file):
+        """Create tunnel config file"""
+        config = {
+            "ingress": [
+                {
+                    "hostname": "{}.{}".format(self.subdomain, self.domain),
+                    "service": "http://localhost:8888"
+                },
+                {
+                    "service": "http_status:404"
+                }
+            ]
+        }
+        
+        config_file = "/tmp/tunnel-config-{}.yml".format(self.tunnel_id)
+        with open(config_file, 'w') as f:
+            f.write("tunnel: {}\n".format(self.tunnel_id))
+            f.write("credentials-file: {}\n\n".format(cred_file))
+            f.write("ingress:\n")
+            f.write("  - hostname: {}.{}\n".format(self.subdomain, self.domain))
+            f.write("    service: http://localhost:8888\n")
+            f.write("  - service: http_status:404\n")
+        
+        return config_file
+    
+    def get_cloudflared_path(self):
+        """Get or download cloudflared"""
+        import shutil
+        if shutil.which("cloudflared"):
+            return "cloudflared"
+        
+        local_bin = os.path.expanduser("~/.local/bin/cloudflared")
+        if os.path.exists(local_bin):
+            return local_bin
+        
+        # Download
+        print("📦 Downloading cloudflared...")
+        import platform
+        system = platform.system().lower()
+        arch = "amd64" if "x86" in platform.machine() else "arm64"
+        url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{}".format(arch)
+        
+        os.makedirs(os.path.dirname(local_bin), exist_ok=True)
+        subprocess.run("curl -L {} -o {}".format(url, local_bin), shell=True, capture_output=True)
+        subprocess.run("chmod +x {}".format(local_bin), shell=True)
+        return local_bin
+    
+    def start_jupyter(self):
+        """Start Jupyter"""
+        print("🚀 Starting Jupyter...")
+        
+        cmd = [
+            "jupyter", "notebook",
+            "--port", "8888",
+            "--no-browser",
+            "--ip", "0.0.0.0",
+            "--NotebookApp.token=''",
+            "--NotebookApp.password=''"
+        ]
+        
+        self.jupyter_process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        
+        time.sleep(3)
+        print("✅ Jupyter started")
+        return True
+    
+    def start_tunnel(self, config_file):
+        """Start tunnel with config"""
+        print("🔧 Starting tunnel...")
+        
+        cloudflared = self.get_cloudflared_path()
+        
+        cmd = [
+            cloudflared,
+            "tunnel",
+            "--config", config_file,
+            "run"
+        ]
+        
+        self.tunnel_process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        
+        time.sleep(5)
+        print("✅ Tunnel running at {}".format(self.jupyter_url))
+        return True
+    
+    def start(self):
+        """Main entry point"""
+        try:
+            print("="*50)
+            print("🌐 Persistent Tunnel with API")
+            print("Device: {}".format(self.device_id))
+            print("Target: {}.{}".format(self.subdomain, self.domain))
+            print("="*50)
+            
+            # API credentials are hardcoded, so we're ready to go
+            
+            # 1. Create tunnel via API
+            cred_file = self.create_tunnel()
+            if not cred_file:
+                print("⚠️  Falling back to quick tunnel")
+                return self.start_quick_tunnel()
+            
+            # 2. Create DNS record
+            self.create_dns_record()
+            
+            # 3. Create config
+            config_file = self.create_tunnel_config(cred_file)
+            
+            # 4. Start services
+            self.start_jupyter()
+            self.start_tunnel(config_file)
+            
+            print("\n" + "="*50)
+            print("🎉 SUCCESS! Persistent URL created:")
+            print("   {}".format(self.jupyter_url))
+            print("   Tunnel ID: {}".format(self.tunnel_id))
+            print("="*50)
+            
+            return True
+            
+        except Exception as e:
+            print("❌ Error: {}".format(e))
+            import traceback
+            traceback.print_exc()
+            self.stop()
+            return False
+    
+    def start_quick_tunnel(self):
+        """Fallback to quick tunnel"""
+        print("🔧 Using quick tunnel (temporary URL)...")
+        
+        # Start Jupyter first
+        self.start_jupyter()
+        
+        # Start quick tunnel
+        cloudflared = self.get_cloudflared_path()
+        cmd = [cloudflared, "tunnel", "--url", "http://localhost:8888"]
+        
+        self.tunnel_process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+        )
+        
+        # Get URL from output
+        for _ in range(30):
+            line = self.tunnel_process.stdout.readline()
+            if "trycloudflare.com" in line:
+                import re
+                match = re.search(r'https://[a-zA-Z0-9-]+\.trycloudflare\.com', line)
+                if match:
+                    self.jupyter_url = match.group(0)
+                    print("✅ Quick tunnel: {}".format(self.jupyter_url))
+                    return True
+            time.sleep(0.5)
+        
+        return False
+    
+    def stop(self):
+        """Stop everything"""
+        if self.jupyter_process:
+            self.jupyter_process.terminate()
+        if self.tunnel_process:
+            self.tunnel_process.terminate()
+        
+        # Optionally delete tunnel when stopping
+        if self.tunnel_id:
+            try:
+                url = "https://api.cloudflare.com/client/v4/accounts/{}/cfd_tunnel/{}".format(
+                    self.cf_account_id, self.tunnel_id
+                )
+                requests.delete(url, headers=self._get_headers())
+                print("🗑️  Tunnel deleted")
+            except Exception as e:
+                pass  # Ignore cleanup errors
+    
+    def run(self):
+        """Run and keep alive"""
+        try:
+            if self.start():
+                print("\nPress Ctrl+C to stop...")
+                while True:
+                    time.sleep(1)
+        except KeyboardInterrupt:
+            print("\n⏹️  Shutting down...")
+            self.stop()
+
+
+def main():
+    import platform
+    import uuid
+    
+    hostname = platform.node().replace('.', '-')[:20]
+    device_id = "{}-{}".format(hostname, str(uuid.uuid4())[:8])
+    
+    print("Device ID: {}".format(device_id))
+    
+    tunnel = PersistentTunnel(device_id=device_id)
+    tunnel.run()
+
+
+if __name__ == "__main__":
+    main()

{unitlab-2.3.28.dist-info → unitlab-2.3.29.dist-info}/METADATA

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

{unitlab-2.3.28.dist-info → unitlab-2.3.29.dist-info}/RECORD

@@ -1,18 +1,23 @@
 unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
 unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
+unitlab/api_tunnel.py,sha256=SzDKFmxUg713KTkysc8qUnSmkfRc_dS3Cqrw2ONjn8I,8259
+unitlab/auto_tunnel.py,sha256=Q4YyxrKOvM6jB1lQZd-QcHwt5SuMa60MpKWKEWF4fhY,5495
 unitlab/binary_manager.py,sha256=Q1v2Odm0hk_3g7jfDUJQfkjEbUbSjtuyo2JDUyWjDrk,5468
-unitlab/client.py,sha256=TAv9ePzs8gGAgqGXkiGCxD-cI5dEGKWnyGKAU6UiR0M,24635
+unitlab/client.py,sha256=roVX8yq1x8LW1XEFuic4G-Cq1QEjsk2CySGkiJbxA78,25759
 unitlab/cloudflare_api_tunnel.py,sha256=XgDOQ-ISNDAJOlbKp96inGix3An_eBnAQ2pORcGBM40,14061
 unitlab/cloudflare_api_tunnel_backup.py,sha256=dG5Vax0JqrF2i-zxAFB-kNGyVSFR01-ovalwuJELqpo,28489
+unitlab/dynamic_tunnel.py,sha256=fHPMouaY2q1N7e4jyre34ZeWk2mx7MKanoPfRnLNmc8,8980
+unitlab/easy_tunnel.py,sha256=yfTGv7i9wtqMpMagpIrIQTrd3jknYwQ6IUgFGbcitKM,6735
 unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
 unitlab/main.py,sha256=7gPZ_2n90sxDnq9oGZVKOkuifr-k7w2Tq3ZIldAUE8I,5877
+unitlab/persistent_tunnel.py,sha256=0ubhsUOJUpDKG0xo18e6mN1V4pxNQvNFjylC1J1QglA,11712
 unitlab/simple_tunnel.py,sha256=vWgVYFEbPoGCHmumujNrfBnDPuUCZgQJkVO3IvdygQA,6812
 unitlab/tunnel_config.py,sha256=7CiAqasfg26YQfJYXapCBQPSoqw4jIx6yR64saybLLo,8312
 unitlab/tunnel_service_token.py,sha256=ji96a4s4W2cFJrHZle0zBD85Ac_T862-gCKzBUomrxM,3125
 unitlab/utils.py,sha256=83ekAxxfXecFTg76Z62BGDybC_skKJHYoLyawCD9wGM,1920
-unitlab-2.3.28.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
-unitlab-2.3.28.dist-info/METADATA,sha256=Ig_y0Z7LQzzQkeE2NIKX6lq46EuKP1VVd1TqURBqfDI,844
-unitlab-2.3.28.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-unitlab-2.3.28.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
-unitlab-2.3.28.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
-unitlab-2.3.28.dist-info/RECORD,,
+unitlab-2.3.29.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
+unitlab-2.3.29.dist-info/METADATA,sha256=OG1XzALj4PXPvmcrJ4l15-DXdelWtgxm5y0Wo9k9uZ8,844
+unitlab-2.3.29.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+unitlab-2.3.29.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
+unitlab-2.3.29.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
+unitlab-2.3.29.dist-info/RECORD,,