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

unitlab/client.py

@@ -17,6 +17,7 @@ import psutil
 from datetime import datetime, timezone
 from .tunnel_config import CloudflareTunnel
 from .cloudflare_api_tunnel import CloudflareAPITunnel
+from .simple_tunnel import SimpleTunnel
 from .utils import get_api_url, handle_exceptions
 from pathlib import Path
 
@@ -37,9 +38,6 @@ except ImportError:
     pass  # dotenv not installed, use system env vars only
 
 
-
-
-
 logger = logging.getLogger(__name__)
 
 class UnitlabClient:
@@ -283,24 +281,12 @@ class UnitlabClient:
         self.device_id = device_id
         self.base_domain = base_domain
         
-        # Always use API-based tunnel now that we have hardcoded credentials
-        # This provides better SSH/Jupyter separation with j/s prefixes
-        try:
-            logger.info("Using API-based Cloudflare tunnel management")
-            self.tunnel_manager = CloudflareAPITunnel(device_id, base_domain)
-            self.jupyter_url = self.tunnel_manager.jupyter_url
-            self.ssh_url = self.tunnel_manager.ssh_url
-        except Exception as e:
-            logger.warning(f"Failed to initialize API tunnel, falling back: {e}")
-            if CloudflareTunnel:
-                logger.info("Using service token Cloudflare tunnel")
-                self.tunnel_manager = CloudflareTunnel(base_domain, device_id)
-                self.jupyter_url = self.tunnel_manager.jupyter_url
-                self.ssh_url = self.tunnel_manager.ssh_url
-            else:
-                self.tunnel_manager = None
-                self.jupyter_url = f"https://jupyter-{device_id}.{base_domain}"
-                self.ssh_url = f"https://ssh-{device_id}.{base_domain}"
+        # Use the simple hardcoded tunnel approach
+        logger.info("Using simple hardcoded Cloudflare tunnel")
+        self.tunnel_manager = SimpleTunnel(device_id=self.device_id)
+        # SimpleTunnel generates the URL internally based on device_id
+        self.jupyter_url = self.tunnel_manager.jupyter_url
+        self.ssh_url = self.jupyter_url  # Same URL for both services
         
         # Setup signal handlers
         signal.signal(signal.SIGINT, self._handle_shutdown)
@@ -400,23 +386,27 @@ class UnitlabClient:
     def setup_tunnels(self) -> bool:
         """Setup Cloudflare tunnels"""
         try:
-            if not self.jupyter_port:
-                logger.error("Jupyter port not available")
-                return False
-            
             if not self.tunnel_manager:
-                logger.warning("CloudflareTunnel not available, skipping tunnel setup")
+                logger.warning("Tunnel manager not available, skipping tunnel setup")
                 return True
             
-            logger.info("Setting up Cloudflare tunnels...")
-            self.tunnel_proc = self.tunnel_manager.setup(self.jupyter_port)
+            logger.info("Setting up Cloudflare tunnel...")
             
-            if self.tunnel_proc:
-                logger.info("✅ Tunnels established")
+            # SimpleTunnel handles both Jupyter and tunnel startup internally
+            # It doesn't need the jupyter_port parameter since it starts its own Jupyter
+            if self.tunnel_manager.start():
+                # Store the processes for monitoring
+                self.jupyter_proc = self.tunnel_manager.jupyter_process
+                self.tunnel_proc = self.tunnel_manager.tunnel_process
+                self.jupyter_port = "8888"  # SimpleTunnel uses fixed port
+                
+                # The tunnel is now running
+                logger.info("✅ Tunnel and Jupyter established")
                 self.report_services()
                 return True
-            
-            return False
+            else:
+                logger.error("Failed to start tunnel")
+                return False
             
         except Exception as e:
             logger.error(f"Tunnel setup failed: {e}")
@@ -603,13 +593,9 @@ class UnitlabClient:
         # Check SSH
         self.check_ssh()
         
-        # Start Jupyter
-        if not self.start_jupyter():
-            logger.error("Failed to start Jupyter")
-            return
-        
-        # Wait a moment for Jupyter to fully initialize
-        time.sleep(1)
+        # SimpleTunnel handles Jupyter internally, so we don't start it separately
+        # Just setup the tunnels which will also start Jupyter
+        logger.info("Starting integrated Jupyter and tunnel...")
         
         # Setup tunnels
         if not self.setup_tunnels():
@@ -648,22 +634,28 @@ class UnitlabClient:
         
         self.running = False
         
-        # Stop Jupyter
-        if self.jupyter_proc:
-            logger.info("Stopping Jupyter...")
-            self.jupyter_proc.terminate()
-            try:
-                self.jupyter_proc.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                self.jupyter_proc.kill()
-        
-        # Stop tunnel
-        if self.tunnel_proc:
-            logger.info("Stopping tunnel...")
-            self.tunnel_proc.terminate()
-            try:
-                self.tunnel_proc.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                self.tunnel_proc.kill()
+        # With SimpleTunnel, we just call stop() method
+        if self.tunnel_manager and hasattr(self.tunnel_manager, 'stop'):
+            logger.info("Stopping tunnel and Jupyter...")
+            self.tunnel_manager.stop()
+        else:
+            # Fallback to individual process cleanup
+            # Stop Jupyter
+            if self.jupyter_proc:
+                logger.info("Stopping Jupyter...")
+                self.jupyter_proc.terminate()
+                try:
+                    self.jupyter_proc.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    self.jupyter_proc.kill()
+            
+            # Stop tunnel
+            if self.tunnel_proc:
+                logger.info("Stopping tunnel...")
+                self.tunnel_proc.terminate()
+                try:
+                    self.tunnel_proc.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    self.tunnel_proc.kill()
         
         logger.info("Cleanup complete")

unitlab/simple_tunnel.py

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

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

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

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

@@ -1,17 +1,18 @@
 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=HUQnBSMSk3RhR_Qwb_hVteuXGAZ43shF2-5k4vGELoE,24558
+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=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.26.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
-unitlab-2.3.26.dist-info/METADATA,sha256=TF74xe3wSNg3DliLbBbuGvOREfyqa94he4iCmWelTgA,844
-unitlab-2.3.26.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-unitlab-2.3.26.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
-unitlab-2.3.26.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
-unitlab-2.3.26.dist-info/RECORD,,
+unitlab-2.3.28.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
+unitlab-2.3.28.dist-info/METADATA,sha256=Ig_y0Z7LQzzQkeE2NIKX6lq46EuKP1VVd1TqURBqfDI,844
+unitlab-2.3.28.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+unitlab-2.3.28.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
+unitlab-2.3.28.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
+unitlab-2.3.28.dist-info/RECORD,,