unitlab 2.3.26__tar.gz → 2.3.27__tar.gz

{unitlab-2.3.26/src/unitlab.egg-info → unitlab-2.3.27}/PKG-INFO

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

{unitlab-2.3.26 → unitlab-2.3.27}/setup.py

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

{unitlab-2.3.26 → unitlab-2.3.27}/src/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-2.3.27/src/unitlab/simple_tunnel.py

@@ -0,0 +1,158 @@
+#!/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 start_tunnel(self, local_port=8888):
+        """Start cloudflared tunnel - simple and direct"""
+        print("🔧 Starting Cloudflare tunnel...")
+        
+        # Simple command - just run the tunnel
+        cmd = [
+            "cloudflared",  # Use system 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 → unitlab-2.3.27/src/unitlab.egg-info}/PKG-INFO

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

{unitlab-2.3.26 → unitlab-2.3.27}/src/unitlab.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/unitlab/cloudflare_api_tunnel.py
 src/unitlab/cloudflare_api_tunnel_backup.py
 src/unitlab/exceptions.py
 src/unitlab/main.py
+src/unitlab/simple_tunnel.py
 src/unitlab/tunnel_config.py
 src/unitlab/tunnel_service_token.py
 src/unitlab/utils.py