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

unitlab/persistent_tunnel.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Persistent Tunnel - Each device gets deviceid.1scan.uz
+Persistent Tunnel - Each device gets deviceid.unitlab-ai.com
 Uses Cloudflare API to create named tunnels
 """
 
@@ -10,18 +10,32 @@ import json
 import time
 import os
 import base64
+from fastapi import FastAPI
+import uvicorn
+import threading
+import psutil
+
+
+api = FastAPI()
+
+@api.get("/api-agent/")
+def get_cpu_info():
+    cpu_usage_percent = psutil.cpu_percent(interval=1)
+    ram = psutil.virtual_memory()
+    return  {"cpu_percentage": cpu_usage_percent, 'cpu_count': psutil.cpu_count(), 'ram_usage': ram.used }
+
 
 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
+        
+        self.cf_api_key = "RoIAn1t9rMqcGK7_Xja216pxbRTyFafC1jeRKIO3"  
         
         # Account and Zone IDs
-        self.cf_account_id = "c91192ae20a5d43f65e087550d8dc89b"  # Your account ID
-        self.cf_zone_id = "78182c3883adad79d8f1026851a68176"  # Zone ID for 1scan.uz
+        self.cf_account_id = "29df28cf48a30be3b1aa344b840400e6"  # Your account ID
+        self.cf_zone_id = "eae80a730730b3b218a80dace996535a"  # Zone ID for unitlab-ai.com
         
         # Clean device ID for subdomain
         if device_id:
@@ -32,16 +46,19 @@ class PersistentTunnel:
         
         self.tunnel_name = "agent-{}".format(self.device_id)
         self.subdomain = self.device_id
-        self.domain = "1scan.uz"
+        self.domain = "unitlab-ai.com"
         self.jupyter_url = "https://{}.{}".format(self.subdomain, self.domain)
-        
+        self.api_expose_url = "https://{}.{}/api-agent/".format(self.subdomain, self.domain)
+        self.ssh_subdomain = "s{}".format(self.device_id)  # Shorter SSH subdomain to avoid length issues
+        self.ssh_url = "{}.{}".format(self.ssh_subdomain, self.domain)  # SSH on s{deviceid}.unitlab-ai.com
+
         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"""
+        """Get Zone ID for unitlab-ai.com"""
         print("🔍 Getting Zone ID for {}...".format(self.domain))
         
         url = "https://api.cloudflare.com/client/v4/zones"
@@ -61,11 +78,12 @@ class PersistentTunnel:
     
     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"
-        }
+     
+    
+        return { 
+            "Authorization":  f"Bearer {self.cf_api_key}",                                                                                                                                                         
+            "Content-Type": "application/json"                                                                                          
+        } 
     
     def get_or_create_tunnel(self):
         """Get existing tunnel or create a new one"""
@@ -133,15 +151,15 @@ class PersistentTunnel:
             print("✅ Tunnel created: {}".format(self.tunnel_id))
             return cred_file
         else:
-            print("❌ Failed to create tunnel: {}".format(response.text[:200]))
+            print("❌ Failed to create tunnel: {}".format(response.text))
             return None
     
     def create_dns_record(self):
-        """Create DNS CNAME record"""
+        """Create DNS CNAME records for main domain and SSH subdomain"""
         if not self.tunnel_id:
             return False
         
-        print("🔧 Creating DNS record: {}.{}...".format(self.subdomain, self.domain))
+        print("🔧 Creating DNS records...")
         
         # Get zone ID if we don't have it
         if self.cf_zone_id == "NEED_ZONE_ID_FOR_1SCAN_UZ":
@@ -150,6 +168,7 @@ class PersistentTunnel:
         url = "https://api.cloudflare.com/client/v4/zones/{}/dns_records".format(self.cf_zone_id)
         headers = self._get_headers()
         
+        # Create main subdomain record for Jupyter and API
         data = {
             "type": "CNAME",
             "name": self.subdomain,
@@ -161,13 +180,83 @@ class PersistentTunnel:
         response = requests.post(url, headers=headers, json=data)
         
         if response.status_code in [200, 201]:
-            print("✅ DNS record created")
-            return True
+            print("✅ Main DNS record created: {}.{}".format(self.subdomain, self.domain))
         elif "already exists" in response.text:
-            print("⚠️  DNS record already exists")
+            print("⚠️  Main DNS record already exists: {}.{}".format(self.subdomain, self.domain))
+        else:
+            print("❌ Failed to create main DNS: {}".format(response.text[:200]))
+            return False
+        
+        # Create SSH subdomain record (s{deviceid}.unitlab-ai.com)
+        ssh_data = {
+            "type": "CNAME",
+            "name": self.ssh_subdomain,
+            "content": "{}.cfargotunnel.com".format(self.tunnel_id),
+            "proxied": True,
+            "ttl": 1
+        }
+        
+        ssh_response = requests.post(url, headers=headers, json=ssh_data)
+        
+        if ssh_response.status_code in [200, 201]:
+            print("✅ SSH DNS record created: {}.{}".format(self.ssh_subdomain, self.domain))
+        elif "already exists" in ssh_response.text:
+            print("⚠️  SSH DNS record already exists: {}.{}".format(self.ssh_subdomain, self.domain))
+        else:
+            print("⚠️  Could not create SSH DNS: {}".format(ssh_response.text[:200]))
+            # SSH is optional, so we continue even if SSH DNS fails
+        
+        return True
+    
+    def create_access_application(self):
+        """Create Cloudflare Access application for SSH with bypass policy"""
+        print("🔧 Creating Access application for SSH...")
+        
+        # Create Access application
+        app_url = "https://api.cloudflare.com/client/v4/zones/{}/access/apps".format(self.cf_zone_id)
+        headers = self._get_headers()
+        
+        app_data = {
+            "name": "SSH-{}".format(self.device_id),
+            "domain": "{}.{}".format(self.ssh_subdomain, self.domain),
+            "type": "ssh",
+            "session_duration": "24h",
+            "auto_redirect_to_identity": False
+        }
+        
+        app_response = requests.post(app_url, headers=headers, json=app_data)
+        
+        if app_response.status_code in [200, 201]:
+            app_id = app_response.json()["result"]["id"]
+            print("✅ Access application created: {}".format(app_id))
+            
+            # Create bypass policy (no authentication required)
+            policy_url = "https://api.cloudflare.com/client/v4/zones/{}/access/apps/{}/policies".format(
+                self.cf_zone_id, app_id
+            )
+            
+            policy_data = {
+                "name": "Public Access",
+                "decision": "bypass",
+                "include": [
+                    {"everyone": {}}
+                ],
+                "precedence": 1
+            }
+            
+            policy_response = requests.post(policy_url, headers=headers, json=policy_data)
+            
+            if policy_response.status_code in [200, 201]:
+                print("✅ Bypass policy created - SSH is publicly accessible")
+                return True
+            else:
+                print("⚠️  Could not create bypass policy: {}".format(policy_response.text[:200]))
+                return False
+        elif "already exists" in app_response.text:
+            print("⚠️  Access application already exists")
             return True
         else:
-            print("❌ Failed to create DNS: {}".format(response.text[:200]))
+            print("⚠️  Could not create Access application: {}".format(app_response.text[:200]))
             return False
     
     def create_tunnel_config(self, cred_file):
@@ -177,11 +266,24 @@ class PersistentTunnel:
             f.write("tunnel: {}\n".format(self.tunnel_id))
             f.write("credentials-file: {}\n\n".format(cred_file))
             f.write("ingress:\n")
+
+            # SSH service on dedicated subdomain (s{deviceid}.unitlab-ai.com)
+            f.write("  - hostname: {}.{}\n".format(self.ssh_subdomain, self.domain))
+            f.write("    service: ssh://localhost:22\n")
+
+            # API (more specific path goes first)
+            f.write("  - hostname: {}.{}\n".format(self.subdomain, self.domain))
+            f.write("    path: /api-agent/*\n")
+            f.write("    service: http://localhost:8001\n")
+
+            # Jupyter (general hostname for HTTP)
             f.write("  - hostname: {}.{}\n".format(self.subdomain, self.domain))
             f.write("    service: http://localhost:8888\n")
+
+            # Catch-all 404 (MUST be last!)
             f.write("  - service: http_status:404\n")
-        
-        return config_file
+        return config_file 
+
     
     def get_cloudflared_path(self):
         """Get or download cloudflared for any platform"""
@@ -255,6 +357,9 @@ class PersistentTunnel:
         print("✅ cloudflared downloaded successfully")
         return local_bin
     
+   
+
+    
     def start_jupyter(self):
         """Start Jupyter"""
         print("🚀 Starting Jupyter...")
@@ -274,31 +379,59 @@ class PersistentTunnel:
         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_api(self):
+        def run_api():
+            uvicorn.run(
+                api,
+                port=8001
+            )
+        
+        api_thread = threading.Thread(target=run_api, daemon=True)
+        api_thread.start()
+        print('API is started')
+
+    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(2)                                                                            
+                                                                                                
+        # Check if process is still running                                                      
+        if self.tunnel_process.poll() is not None:                                               
+            print("❌ Tunnel process died!")                                                      
+            # Try to read error output                                                           
+            try:                                                                                 
+                stdout, stderr = self.tunnel_process.communicate(timeout=1)                      
+                if stderr:                                                                       
+                    print(f"Error: {stderr.decode()}")                                           
+                if stdout:                                                                       
+                    print(f"Output: {stdout.decode()}")                                          
+            except:                                                                              
+                pass                                                                             
+            return False                                                                         
+                                                                                                
+        print("✅ Tunnel running at {}".format(self.jupyter_url))                                 
+        print("✅ API running at {}".format(self.api_expose_url))
+        print("✅ SSH available at {}".format(self.ssh_url))                                        
+        return True        
     
     def start(self):
         """Main entry point"""
@@ -313,25 +446,37 @@ class PersistentTunnel:
             
             # 1. Get existing or create new tunnel via API
             cred_file = self.get_or_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
+            # 3. Create Access application for SSH
+            self.create_access_application()
+            
+            # 4. Create config
             config_file = self.create_tunnel_config(cred_file)
             
-            # 4. Start services
+            # 5. Start services
             self.start_jupyter()
+            self.start_api()
             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("🎉 SUCCESS! Persistent URLs created:")
+            print("📔 Jupyter:   {}".format(self.jupyter_url))
+            print("🔧 API:       {}".format(self.api_expose_url))
+            print("🔐 SSH:       {}".format(self.ssh_url))
+            print("")
+            print("SSH Connection Command:")
+            import getpass
+            current_user = getpass.getuser()
+            print("ssh -o ProxyCommand='cloudflared access ssh --hostname {}' {}@{}".format(
+                self.ssh_url, current_user, self.ssh_url))
+            print("")
+            print("Tunnel ID: {}".format(self.tunnel_id))
             print("="*50)
+  
             
             return True
             

unitlab/utils.py

@@ -66,3 +66,5 @@ def get_api_url() -> str:
     except Exception:
         return "https://api.unitlab.ai"
 
+
+

{unitlab-2.3.33.dist-info → unitlab-2.3.35.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: unitlab
-Version: 2.3.33
+Version: 2.3.35
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai
@@ -25,4 +25,13 @@ Requires-Dist: psutil
 Requires-Dist: pyyaml
 Requires-Dist: jupyter
 Requires-Dist: python-dotenv
-
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist

unitlab-2.3.35.dist-info/RECORD

@@ -0,0 +1,13 @@
+unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
+unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
+unitlab/client.py,sha256=wqREtDuYc5ixeloPEGm0hp1sdUtB59sB1bIJjBcO1y0,25983
+unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
+unitlab/main.py,sha256=kazASmzhPaAcf9hsPZdewcry_vplsrRLfziPxKlPT70,4425
+unitlab/persistent_tunnel.py,sha256=AHiOTVkxAlwsV0-19wxuX6-I_1l3rwv9hQiCSyLOFrA,23410
+unitlab/utils.py,sha256=9gPRu-d6pbhSoVdll1GXe4eoz_uFYOSbYArFDQdlUZs,1922
+unitlab-2.3.35.dist-info/licenses/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
+unitlab-2.3.35.dist-info/METADATA,sha256=x1Oucw_bpzTjYQbkIl56g2f7I-28eE5vmWFR0TqsKvA,1046
+unitlab-2.3.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+unitlab-2.3.35.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
+unitlab-2.3.35.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
+unitlab-2.3.35.dist-info/RECORD,,

{unitlab-2.3.33.dist-info → unitlab-2.3.35.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

unitlab/api_tunnel.py

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