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

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/simple_tunnel.py

@@ -61,13 +61,60 @@ class SimpleTunnel:
         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",  # Use system cloudflared
+            cloudflared,
             "tunnel",
             "run",
             "--url", "http://127.0.0.1:{}".format(local_port),

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

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

unitlab-2.3.29.dist-info/RECORD

@@ -0,0 +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=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.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,,

unitlab-2.3.27.dist-info/RECORD

@@ -1,18 +0,0 @@
-unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
-unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-unitlab/binary_manager.py,sha256=Q1v2Odm0hk_3g7jfDUJQfkjEbUbSjtuyo2JDUyWjDrk,5468
-unitlab/client.py,sha256=TAv9ePzs8gGAgqGXkiGCxD-cI5dEGKWnyGKAU6UiR0M,24635
-unitlab/cloudflare_api_tunnel.py,sha256=XgDOQ-ISNDAJOlbKp96inGix3An_eBnAQ2pORcGBM40,14061
-unitlab/cloudflare_api_tunnel_backup.py,sha256=dG5Vax0JqrF2i-zxAFB-kNGyVSFR01-ovalwuJELqpo,28489
-unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
-unitlab/main.py,sha256=7gPZ_2n90sxDnq9oGZVKOkuifr-k7w2Tq3ZIldAUE8I,5877
-unitlab/simple_tunnel.py,sha256=vA6OP2ogvDlRxXlu52acNcdgZYNMI2G-m2V7bv2kyrY,4867
-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.27.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
-unitlab-2.3.27.dist-info/METADATA,sha256=A7IdVROWEy8jsfuER5nXt83nMOw-W8X7ZSgLeQyCHy0,844
-unitlab-2.3.27.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-unitlab-2.3.27.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
-unitlab-2.3.27.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
-unitlab-2.3.27.dist-info/RECORD,,