unitlab 2.3.33__py3-none-any.whl → 2.3.35__py3-none-any.whl

unitlab/dynamic_tunnel.py

@@ -1,272 +0,0 @@
-#!/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

@@ -1,210 +0,0 @@
-#!/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/simple_tunnel.py

@@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple Cloudflare Tunnel for Jupyter - MVP Version
-Uses hardcoded tunnel credentials
-"""
-
-import subprocess
-from pathlib import Path
-import time
-
-
-class SimpleTunnel:
-    def __init__(self, device_id=None):
-        """
-        Initialize SimpleTunnel with hardcoded everything
-        device_id: Unique device identifier for subdomain generation
-        """
-        # Everything hardcoded for simplicity
-        self.tunnel_uuid = "c6caf64a-7499-4aa5-8702-0d1870388114"
-        self.domain = "1scan.uz"
-        
-        # Generate unique subdomain from device_id
-        if device_id:
-            # Clean device_id: remove special chars, lowercase, limit length
-            clean_id = device_id.replace('-', '').replace('_', '').replace('.', '').lower()[:30]
-            self.subdomain = clean_id
-        else:
-            # Fallback to a random subdomain if no device_id
-            import uuid
-            self.subdomain = str(uuid.uuid4())[:8]
-        
-        # The unique URL for this device
-        self.jupyter_url = "https://{}.{}".format(self.subdomain, self.domain)
-        
-        self.jupyter_process = None
-        self.tunnel_process = None
-    
-    def start_jupyter(self, port=8888):
-        """Start Jupyter notebook server"""
-        print("🚀 Starting Jupyter on port {}...".format(port))
-        
-        cmd = [
-            "jupyter", "notebook",
-            "--port", '8888',
-            "--no-browser",
-            "--ip", "0.0.0.0",
-            "--ServerApp.token=''",
-            "--ServerApp.password=''",
-            "--ServerApp.allow_origin='*'"
-        ]
-        
-        self.jupyter_process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
-        
-        # Wait for Jupyter to start
-        time.sleep(3)
-        
-        print("✅ Jupyter started on port {}".format(port))
-        return True
-    
-    def get_cloudflared_path(self):
-        """Get cloudflared binary, download if needed"""
-        import os
-        import platform
-        
-        # Check if cloudflared exists in system
-        try:
-            import shutil
-            if shutil.which("cloudflared"):
-                print("✅ Using system cloudflared")
-                return "cloudflared"
-        except:
-            pass
-        
-        # Check local binary
-        local_bin = os.path.expanduser("~/.local/bin/cloudflared")
-        if os.path.exists(local_bin):
-            print("✅ Using existing cloudflared from ~/.local/bin")
-            return local_bin
-        
-        # Download it
-        print("📦 Downloading cloudflared (this may take a moment)...")
-        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)
-            result = subprocess.run("curl -L {} -o {}".format(url, local_bin), shell=True, capture_output=True)
-            if result.returncode == 0:
-                subprocess.run("chmod +x {}".format(local_bin), shell=True)
-                print("✅ cloudflared downloaded successfully")
-                return local_bin
-            else:
-                print("❌ Failed to download cloudflared")
-                raise Exception("Could not download cloudflared")
-        
-        raise Exception("Could not find or download cloudflared")
-    
-    def start_tunnel(self, local_port=8888):
-        """Start cloudflared tunnel - simple and direct"""
-        print("🔧 Starting Cloudflare tunnel...")
-        
-        # Get cloudflared (downloads if needed)
-        try:
-            cloudflared = self.get_cloudflared_path()
-        except Exception as e:
-            print("⚠️ Error getting cloudflared: {}".format(e))
-            # Fallback - try to use system cloudflared anyway
-            cloudflared = "cloudflared"
-        
-        # Simple command - just run the tunnel
-        cmd = [
-            cloudflared,
-            "tunnel",
-            "run",
-            "--url", "http://127.0.0.1:{}".format(local_port),
-            self.tunnel_uuid
-        ]
-        
-        self.tunnel_process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE
-        )
-        
-        # Wait for tunnel to establish
-        time.sleep(3)
-        
-        print("✅ Tunnel running at {}".format(self.jupyter_url))
-    
-    def start(self):
-        """Start tunnel and Jupyter (non-blocking)"""
-        try:
-            print("="*50)
-            print("🌐 Simple Cloudflare Tunnel for Jupyter - MVP") 
-            print("="*50)
-            
-            # 1. Cloudflared should be installed on system
-            
-            # 2. Start Jupyter
-            if not self.start_jupyter():
-                raise Exception("Failed to start Jupyter")
-            
-            # 3. Start tunnel
-            self.start_tunnel()
-            
-            # 4. Print access info
-            print("\n" + "="*50)
-            print("🎉 SUCCESS! Your Jupyter is now accessible at:")
-            print("   {}".format(self.jupyter_url))
-            print("   Device subdomain: {}".format(self.subdomain))
-            print("="*50)
-            
-            return True
-            
-        except Exception as e:
-            print("❌ Error: {}".format(e))
-            self.stop()
-            return False
-    
-    def stop(self):
-        """Stop tunnel and Jupyter"""
-        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):
-        """Main entry point for standalone use - sets up everything and blocks"""
-        try:
-            if self.start():
-                # Keep running
-                while True:
-                    time.sleep(1)
-        except KeyboardInterrupt:
-            print("\n⏹️  Shutting down...")
-            self.stop()
-            print("👋 Goodbye!")
-
-
-def main():
-    """Example usage with device ID"""
-    
-    # Generate a unique device ID (in real usage, this comes from main.py)
-    import platform
-    import uuid
-    hostname = platform.node().replace('.', '-').replace(' ', '-')[:20]
-    random_suffix = str(uuid.uuid4())[:8]
-    device_id = "{}-{}".format(hostname, random_suffix)
-    
-    print("Device ID: {}".format(device_id))
-    
-    # Create tunnel with device ID for unique subdomain
-    tunnel = SimpleTunnel(device_id=device_id)
-    tunnel.run()
-
-
-if __name__ == "__main__":
-    main()