unitlab 2.3.42__tar.gz → 2.3.44__tar.gz

{unitlab-2.3.42/src/unitlab.egg-info → unitlab-2.3.44}/PKG-INFO

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

{unitlab-2.3.42 → unitlab-2.3.44}/setup.py

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

{unitlab-2.3.42 → unitlab-2.3.44}/src/unitlab/persistent_tunnel.py

@@ -38,25 +38,37 @@ class PersistentTunnel:
         
         # Clean device ID for subdomain
         if device_id:
-            self.device_id = device_id.replace('_', '').replace('.', '').lower()[:30]
+            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)
+        # Main tunnel for Jupyter/API
+        self.main_tunnel_name = "agent-{}".format(self.device_id)
+        self.main_tunnel_id = None
+        self.main_tunnel_process = None
+        self.main_tunnel_credentials = None
+        
+        # SSH tunnel
+        self.ssh_tunnel_name = "ssh-{}".format(self.device_id)
+        self.ssh_tunnel_id = None
+        self.ssh_tunnel_process = None
+        self.ssh_tunnel_credentials = None
+        
+        # URLs
         self.subdomain = self.device_id
         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.ssh_subdomain = "ssh{}".format(self.device_id)
+        self.ssh_url = "{}.{}".format(self.ssh_subdomain, self.domain)
 
-        self.tunnel_id = None
-        self.tunnel_credentials = None
         self.jupyter_process = None
-        self.tunnel_process = None
-    
     
+    @property
+    def tunnel_process(self):
+        """Compatibility property for backward compatibility"""
+        return self.main_tunnel_process
     
     def _get_headers(self):
         """Get API headers for Global API Key"""
@@ -79,9 +91,49 @@ class PersistentTunnel:
     #     return self.create_new_tunnel()
 
 
-    def create_new_tunnel(self):
-        """Create a new tunnel via Cloudflare API"""
-        print("🔧 Creating new tunnel: {}...".format(self.tunnel_name))
+    def create_main_tunnel(self):
+        """Create main tunnel for Jupyter/API"""
+        print("🔧 Creating main tunnel: {}...".format(self.main_tunnel_name))
+        
+        # Generate random tunnel secret (32 bytes)
+        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.main_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.main_tunnel_id = result["id"]
+            
+            # Create credentials JSON
+            self.main_tunnel_credentials = {
+                "AccountTag": self.cf_account_id,
+                "TunnelSecret": tunnel_secret,
+                "TunnelID": self.main_tunnel_id
+            }
+            
+            # Save credentials to file
+            cred_file = "/tmp/tunnel-{}.json".format(self.main_tunnel_name)
+            with open(cred_file, 'w') as f:
+                json.dump(self.main_tunnel_credentials, f)
+            
+            print("✅ Main tunnel created: {}".format(self.main_tunnel_id))
+            print("✅ Credentials saved to: {}".format(cred_file))
+            return cred_file
+        else:
+            print("❌ Failed to create main tunnel: {}".format(response.text))
+            return None
+    
+    def create_ssh_tunnel(self):
+        """Create SSH tunnel"""
+        print("🔧 Creating SSH tunnel: {}...".format(self.ssh_tunnel_name))
         
         # Generate random tunnel secret (32 bytes)
         tunnel_secret = base64.b64encode(secrets.token_bytes(32)).decode()
@@ -90,7 +142,7 @@ class PersistentTunnel:
         headers = self._get_headers()
         
         data = {
-            "name": self.tunnel_name,
+            "name": self.ssh_tunnel_name,
             "tunnel_secret": tunnel_secret
         }
         
@@ -98,36 +150,34 @@ class PersistentTunnel:
         
         if response.status_code in [200, 201]:
             result = response.json()["result"]
-            self.tunnel_id = result["id"]
+            self.ssh_tunnel_id = result["id"]
             
             # Create credentials JSON
-            self.tunnel_credentials = {
+            self.ssh_tunnel_credentials = {
                 "AccountTag": self.cf_account_id,
                 "TunnelSecret": tunnel_secret,
-                "TunnelID": self.tunnel_id
+                "TunnelID": self.ssh_tunnel_id
             }
             
             # Save credentials to file
-            cred_file = "/tmp/tunnel-{}.json".format(self.tunnel_name)
+            cred_file = "/tmp/tunnel-{}.json".format(self.ssh_tunnel_name)
             with open(cred_file, 'w') as f:
-                json.dump(self.tunnel_credentials, f)
+                json.dump(self.ssh_tunnel_credentials, f)
             
-            print("✅ Tunnel created: {}".format(self.tunnel_id))
+            print("✅ SSH tunnel created: {}".format(self.ssh_tunnel_id))
             print("✅ Credentials saved to: {}".format(cred_file))
             return cred_file
         else:
-            print("❌ Failed to create tunnel: {}".format(response.text))
+            print("❌ Failed to create SSH tunnel: {}".format(response.text))
             return None
     
-    def create_dns_record(self):
-        """Create DNS CNAME records for main domain and SSH subdomain"""
-        if not self.tunnel_id:
+    def create_dns_records(self):
+        """Create DNS CNAME records for both tunnels"""
+        if not self.main_tunnel_id or not self.ssh_tunnel_id:
             return False
         
         print("🔧 Creating DNS records...")
         
-        # self.get_zone_id()
-        
         url = "https://api.cloudflare.com/client/v4/zones/{}/dns_records".format(self.cf_zone_id)
         headers = self._get_headers()
         
@@ -135,7 +185,7 @@ class PersistentTunnel:
         data = {
             "type": "CNAME",
             "name": self.subdomain,
-            "content": "{}.cfargotunnel.com".format(self.tunnel_id),
+            "content": "{}.cfargotunnel.com".format(self.main_tunnel_id),
             "proxied": True,
             "ttl": 1
         }
@@ -150,58 +200,31 @@ class PersistentTunnel:
             print("❌ Failed to create main DNS: {}".format(response.text[:200]))
             return False
         
-        # First, check if SSH DNS record exists and delete it
-        # print("🔍 Checking for existing SSH DNS record: {}.{}".format(self.ssh_subdomain, self.domain))
-        # list_url = "{}?name={}.{}".format(url, self.ssh_subdomain, self.domain)
-        # list_response = requests.get(list_url, headers=headers)
-        
-        # if list_response.status_code == 200:
-        #     records = list_response.json().get("result", [])
-        #     print("Found {} existing DNS records".format(len(records)))
-        #     print('this is new version')
-        #     for record in records:
-        #         if record["name"] == "{}.{}".format(self.ssh_subdomain, self.domain):
-        #             record_id = record["id"]
-        #             print("🗑️  Deleting old SSH DNS record: {}".format(record_id))
-        #             delete_url = "{}/{}".format(url, record_id)
-        #             delete_response = requests.delete(delete_url, headers=headers)
-        #             if delete_response.status_code in [200, 204]:
-        #                 print("✅ Deleted old SSH DNS record")
-        #             else:
-        #                 print("⚠️  Could not delete old SSH DNS record: {}".format(delete_response.text[:200]))
-        # else:
-        #     print("⚠️  Could not list DNS records: {}".format(list_response.text[:200]))
-        
-        # Wait a moment for DNS deletion to propagate
+        # Wait a moment for DNS propagation
         time.sleep(2)
         
-        # Create new SSH subdomain record pointing to new tunnel
+        # Create SSH subdomain record pointing to SSH tunnel
         ssh_data = {
             "type": "CNAME",
             "name": self.ssh_subdomain,
-            "content": "{}.cfargotunnel.com".format(self.tunnel_id),
+            "content": "{}.cfargotunnel.com".format(self.ssh_tunnel_id),
             "proxied": True,
             "ttl": 1
         }
         
-        print("📝 Creating SSH DNS record: {} -> {}".format(self.ssh_subdomain, self.tunnel_id))
+        print("📝 Creating SSH DNS record: {} -> {}".format(self.ssh_subdomain, self.ssh_tunnel_id))
         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))
-            print("   Points to: {}.cfargotunnel.com".format(self.tunnel_id))
+            return True
+        elif "already exists" in ssh_response.text:
+            print("⚠️  SSH DNS record already exists")
+            return True
         else:
-            print("❌ Failed to create SSH DNS: Status {} - {}".format(ssh_response.status_code, ssh_response.text))
-            # Try to parse error
-            try:
-                error_data = ssh_response.json()
-                if "errors" in error_data:
-                    for error in error_data["errors"]:
-                        print("   Error: {}".format(error.get("message", error)))
-            except:
-                pass
-        
-        return True
+            print("❌ Failed to create SSH DNS: {}".format(ssh_response.text[:200]))
+            return False
+    
     
     def create_access_application(self):
         """Create Cloudflare Access application for SSH with bypass policy"""
@@ -255,34 +278,45 @@ class PersistentTunnel:
             print("⚠️  Could not create Access application: {}".format(app_response.text[:200]))
             return False
     
-    def create_tunnel_config(self, cred_file):
-        """Create tunnel config file"""
-        config_file = "/tmp/tunnel-config-{}.yml".format(self.tunnel_name)
+    def create_main_tunnel_config(self, cred_file):
+        """Create main tunnel config file for Jupyter/API"""
+        config_file = "/tmp/tunnel-config-{}.yml".format(self.main_tunnel_name)
         with open(config_file, 'w') as f:
-            f.write("tunnel: {}\n".format(self.tunnel_id))
+            f.write("tunnel: {}\n".format(self.main_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("    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")
+        
+        print("✅ Main tunnel config created: {}".format(config_file))
+        return config_file
+    
+    def create_ssh_tunnel_config(self, cred_file):
+        """Create SSH tunnel config file"""
+        config_file = "/tmp/tunnel-config-{}.yml".format(self.ssh_tunnel_name)
+        with open(config_file, 'w') as f:
+            f.write("tunnel: {}\n".format(self.ssh_tunnel_id))
+            f.write("credentials-file: {}\n\n".format(cred_file))
+            f.write("ingress:\n")
+
+            # SSH service
+            f.write("  - hostname: {}.{}\n".format(self.ssh_subdomain, self.domain))
+            f.write("    service: ssh://localhost:22\n")
+
+            # Catch-all 404 (MUST be last!)
+            f.write("  - service: http_status:404\n")
+        
+        print("✅ SSH tunnel config created: {}".format(config_file))
         return config_file 
 
     
@@ -357,10 +391,7 @@ class PersistentTunnel:
         
         print("✅ cloudflared downloaded successfully")
         return local_bin
-    
-   
-
-    
+        
     def start_jupyter(self):
         """Start Jupyter"""
         print("🚀 Starting Jupyter...")
@@ -373,8 +404,6 @@ class PersistentTunnel:
             "--NotebookApp.token=''",
             "--NotebookApp.password=''",
             "--NotebookApp.allow_origin='*'"
-
-            
         ]
         
         self.jupyter_process = subprocess.Popen(
@@ -394,77 +423,126 @@ class PersistentTunnel:
         
         api_thread = threading.Thread(target=run_api, daemon=True)
         api_thread.start()
-        print('API is started')
+        print('✅ API 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))                                 
+    def start_main_tunnel(self, config_file):
+        """Start main tunnel for Jupyter/API"""
+        print("🔧 Starting main tunnel...")
+        
+        cloudflared = self.get_cloudflared_path()
+        
+        cmd = [
+            cloudflared,
+            "tunnel",
+            "--config", config_file,
+            "run"
+        ]
+        
+        self.main_tunnel_process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        
+        time.sleep(2)
+        
+        # Check if process is still running
+        if self.main_tunnel_process.poll() is not None:
+            print("❌ Main tunnel process died!")
+            # Try to read error output
+            try:
+                stdout, stderr = self.main_tunnel_process.communicate(timeout=1)
+                if stderr:
+                    print(f"Error: {stderr.decode()}")
+                if stdout:
+                    print(f"Output: {stdout.decode()}")
+            except:
+                pass
+            return False
+        
+        print("✅ Main 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_ssh_tunnel(self, config_file):
+        """Start SSH tunnel"""
+        print("🔧 Starting SSH tunnel...")
+        
+        cloudflared = self.get_cloudflared_path()
+        
+        cmd = [
+            cloudflared,
+            "tunnel",
+            "--config", config_file,
+            "run"
+        ]
+        
+        self.ssh_tunnel_process = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        
+        time.sleep(2)
+        
+        # Check if process is still running
+        if self.ssh_tunnel_process.poll() is not None:
+            print("❌ SSH tunnel process died!")
+            # Try to read error output
+            try:
+                stdout, stderr = self.ssh_tunnel_process.communicate(timeout=1)
+                if stderr:
+                    print(f"Error: {stderr.decode()}")
+                if stdout:
+                    print(f"Output: {stdout.decode()}")
+            except:
+                pass
+            return False
+        
+        print("✅ SSH tunnel running at {}".format(self.ssh_url))
         return True        
     
     def start(self):
         """Main entry point"""
         try:
             print("="*50)
-            print("🌐 Persistent Tunnel with API")
+            print("🌐 Persistent Tunnel with Separate SSH")
             print("Device: {}".format(self.device_id))
-            print("Target: {}.{}".format(self.subdomain, self.domain))
+            print("Main: {}.{}".format(self.subdomain, self.domain))
+            print("SSH: {}.{}".format(self.ssh_subdomain, self.domain))
             print("="*50)
             
-            # API credentials are hardcoded, so we're ready to go
+            # 1. Create main tunnel for Jupyter/API
+            main_cred_file = self.create_main_tunnel()
+            if not main_cred_file:
+                print("❌ Failed to create main tunnel")
+                return False
             
-            # 1. Get existing or create new tunnel via API
-            cred_file = self.create_new_tunnel()
-        
+            # 2. Create SSH tunnel
+            ssh_cred_file = self.create_ssh_tunnel()
+            if not ssh_cred_file:
+                print("❌ Failed to create SSH tunnel")
+                return False
             
-            # 2. Create DNS record
-            self.create_dns_record()
+            # 3. Create DNS records for both tunnels
+            self.create_dns_records()
             
-            # 3. Create Access application for SSH
+            # 4. Create Access application for SSH
             self.create_access_application()
             
-            # 4. Create config
-            config_file = self.create_tunnel_config(cred_file)
+            # 5. Create config files
+            main_config_file = self.create_main_tunnel_config(main_cred_file)
+            ssh_config_file = self.create_ssh_tunnel_config(ssh_cred_file)
             
-            # 5. Start services
+            # 6. Start services (Jupyter and API)
             self.start_jupyter()
             self.start_api()
-            self.start_tunnel(config_file)
+            
+            # 7. Start both tunnels
+            if not self.start_main_tunnel(main_config_file):
+                return False
+            
+            if not self.start_ssh_tunnel(ssh_config_file):
+                return False
             
             print("\n" + "="*50)
-            print("🎉 SUCCESS! Persistent URLs created:")
+            print("🎉 SUCCESS! All services running:")
             print("📔 Jupyter:   {}".format(self.jupyter_url))
             print("🔧 API:       {}".format(self.api_expose_url))
             print("🔐 SSH:       {}".format(self.ssh_url))
@@ -475,7 +553,8 @@ class PersistentTunnel:
             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("Main Tunnel ID: {}".format(self.main_tunnel_id))
+            print("SSH Tunnel ID: {}".format(self.ssh_tunnel_id))
             print("="*50)
   
             
@@ -494,14 +573,30 @@ class PersistentTunnel:
         """Stop everything"""
         if self.jupyter_process:
             self.jupyter_process.terminate()
-        if self.tunnel_process:
-            self.tunnel_process.terminate()
             try:
-                self.tunnel_process.wait(timeout=5)
+                self.jupyter_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.jupyter_process.kill()
+                self.jupyter_process.wait()
+            print("✅ Jupyter stopped")
+        
+        if self.main_tunnel_process:
+            self.main_tunnel_process.terminate()
+            try:
+                self.main_tunnel_process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.main_tunnel_process.kill()
+                self.main_tunnel_process.wait()
+            print("✅ Main tunnel stopped")
+        
+        if self.ssh_tunnel_process:
+            self.ssh_tunnel_process.terminate()
+            try:
+                self.ssh_tunnel_process.wait(timeout=5)
             except subprocess.TimeoutExpired:
-                self.tunnel_process.kill()
-                self.tunnel_process.wait()
-            print("✅ Tunnel stopped")
+                self.ssh_tunnel_process.kill()
+                self.ssh_tunnel_process.wait()
+            print("✅ SSH tunnel stopped")
         
     #     # Optionally delete tunnel when stopping
     #     if self.tunnel_id:
@@ -521,6 +616,13 @@ class PersistentTunnel:
                 print("\nPress Ctrl+C to stop...")
                 while True:
                     time.sleep(1)
+                    # Check if processes are still running
+                    if self.main_tunnel_process and self.main_tunnel_process.poll() is not None:
+                        print("❌ Main tunnel process died!")
+                        break
+                    if self.ssh_tunnel_process and self.ssh_tunnel_process.poll() is not None:
+                        print("❌ SSH tunnel process died!")
+                        break
         except KeyboardInterrupt:
             print("\n⏹️  Shutting down...")
             self.stop()

{unitlab-2.3.42 → unitlab-2.3.44/src/unitlab.egg-info}/PKG-INFO

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