unitlab 2.3.0__py3-none-any.whl → 2.3.4__py3-none-any.whl

unitlab/client.py

@@ -3,16 +3,30 @@ import glob
 import logging
 import os
 import urllib.parse
-
 import aiofiles
 import aiohttp
 import requests
 import tqdm
-
+import socket
+import subprocess
+import signal
+import re
+import time
+import threading
+import psutil
+from datetime import datetime, timezone
+from .tunnel_config import CloudflareTunnel
 from .utils import get_api_url, handle_exceptions
 
-logger = logging.getLogger(__name__)
 
+try:
+    import GPUtil
+    HAS_GPU = True
+except ImportError:
+    HAS_GPU = False
+
+
+logger = logging.getLogger(__name__)
 
 class UnitlabClient:
     """A client with a connection to the Unitlab.ai platform.
@@ -54,6 +68,20 @@ class UnitlabClient:
         adapter = requests.adapters.HTTPAdapter(max_retries=3)
         self.api_session.mount("http://", adapter)
         self.api_session.mount("https://", adapter)
+        
+        # Device agent attributes (initialized when needed)
+        self.device_id = None
+        self.base_domain = None
+        self.server_url = None
+        self.hostname = socket.gethostname()
+        self.tunnel_manager = None
+        self.jupyter_url = None
+        self.ssh_url = None
+        self.jupyter_proc = None
+        self.tunnel_proc = None
+        self.jupyter_port = None
+        self.running = True
+        self.metrics_thread = None
 
     def close(self) -> None:
         """Close :class:`UnitlabClient` connections.
@@ -234,3 +262,372 @@ class UnitlabClient:
                         pbar.update(await f)
 
         asyncio.run(main())
+    
+    def initialize_device_agent(self, server_url: str, device_id: str, base_domain: str):
+        """Initialize device agent configuration"""
+        self.server_url = server_url.rstrip('/')
+        self.device_id = device_id
+        self.base_domain = base_domain
+        
+        # Initialize tunnel manager if available
+        if CloudflareTunnel:
+            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}"
+        
+        # Setup signal handlers
+        signal.signal(signal.SIGINT, self._handle_shutdown)
+        signal.signal(signal.SIGTERM, self._handle_shutdown)
+    
+    def _handle_shutdown(self, signum, frame):
+        """Handle shutdown signals"""
+        _ = frame  # Unused but required by signal handler signature
+        logger.info(f"Received signal {signum}, shutting down...")
+        self.running = False
+    
+    def _get_device_headers(self):
+        """Get headers for device agent API requests"""
+        headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': f'UnitlabDeviceAgent/{self.device_id}'
+        }
+        
+        # Add API key if provided
+        if self.api_key:
+            headers['Authorization'] = f'Api-Key {self.api_key}'
+        
+        return headers
+    
+    def _post_device(self, endpoint, data=None):
+        """Make authenticated POST request for device agent"""
+        full_url = urllib.parse.urljoin(self.server_url, endpoint)
+        logger.debug(f"Posting to {full_url} with data: {data}")
+        
+        try:
+            response = self.api_session.post(
+                full_url,
+                json=data or {},
+                headers=self._get_device_headers(),
+            )
+            logger.debug(f"Response status: {response.status_code}, Response: {response.text}")
+            response.raise_for_status()
+            return response
+        except Exception as e:
+            logger.error(f"POST request failed to {full_url}: {e}")
+            raise
+    
+    def start_jupyter(self) -> bool:
+        """Start Jupyter notebook server"""
+        try:
+            logger.info("Starting Jupyter notebook...")
+            
+            cmd = [
+                "jupyter", "notebook",
+                "--no-browser",
+                "--ServerApp.token=''",
+                "--ServerApp.password=''",
+                "--ServerApp.allow_origin='*'",
+                "--ServerApp.ip='0.0.0.0'"
+            ]
+            
+            self.jupyter_proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True
+            )
+            
+            # Wait for Jupyter to start and get the port
+            start_time = time.time()
+            while time.time() - start_time < 30:
+                line = self.jupyter_proc.stdout.readline()
+                if not line:
+                    break
+                
+                # Look for the port in the output
+                match = re.search(r'http://.*:(\d+)/', line)
+                if match:
+                    self.jupyter_port = match.group(1)
+                    logger.info(f"✅ Jupyter started on port {self.jupyter_port}")
+                    return True
+            
+            raise Exception("Timeout waiting for Jupyter to start")
+            
+        except Exception as e:
+            logger.error(f"Failed to start Jupyter: {e}")
+            if self.jupyter_proc:
+                self.jupyter_proc.terminate()
+                self.jupyter_proc = None
+            return False
+    
+    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")
+                return True
+            
+            logger.info("Setting up Cloudflare tunnels...")
+            self.tunnel_proc = self.tunnel_manager.setup(self.jupyter_port)
+            
+            if self.tunnel_proc:
+                logger.info("✅ Tunnels established")
+                self.report_services()
+                return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"Tunnel setup failed: {e}")
+            return False
+    
+    def check_ssh(self) -> bool:
+        """Check if SSH service is available"""
+        try:
+            # Check if SSH is running
+            result = subprocess.run(
+                ["systemctl", "is-active", "ssh"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            
+            if result.stdout.strip() == "active":
+                logger.info("✅ SSH service is active")
+                return True
+            else:
+                logger.warning("SSH service is not active")
+                # Try to start SSH
+                subprocess.run(["sudo", "systemctl", "start", "ssh"], timeout=10)
+                time.sleep(2)
+                return False
+                
+        except Exception as e:
+            logger.error(f"SSH check failed: {e}")
+            return False
+    
+    def report_services(self):
+        """Report services to the server"""
+        try:
+            # Report Jupyter service
+            jupyter_data = {
+                'service_type': 'jupyter',
+                'service_name': f'jupyter-{self.device_id}',
+                'local_port': int(self.jupyter_port) if self.jupyter_port else 8888,
+                'tunnel_url': self.jupyter_url,
+                'status': 'online'
+            }
+            
+            logger.info(f"Reporting Jupyter service with URL: {self.jupyter_url}")
+            jupyter_response = self._post_device(
+                f"/api/tunnel/agent/jupyter/{self.device_id}/", 
+                jupyter_data
+            )
+            logger.info(f"Reported Jupyter service: {jupyter_response.status_code if hasattr(jupyter_response, 'status_code') else jupyter_response}")
+            
+            # Report SSH service (always report, even if SSH is not running locally)
+            # Remove https:// prefix for SSH hostname
+            ssh_hostname = self.ssh_url.replace('https://', '')
+            
+            # Get current system username
+            import getpass
+            current_user = getpass.getuser()
+            
+            # Create SSH connection command
+            ssh_connection_cmd = f"ssh -o ProxyCommand='cloudflared access ssh --hostname {ssh_hostname}' {current_user}@{ssh_hostname}"
+            
+            # Check if SSH is available
+            ssh_available = self.check_ssh()
+            
+            ssh_data = {
+                'service_type': 'ssh',
+                'service_name': f'ssh-{self.device_id}',
+                'local_port': 22,
+                'tunnel_url': ssh_connection_cmd,  # Send the SSH command instead of URL
+                'status': 'online' if ssh_available else 'offline'
+            }
+            
+            logger.info(f"Reporting SSH service with command: {ssh_connection_cmd}")
+            ssh_response = self._post_device(
+                f"/api/tunnel/agent/ssh/{self.device_id}/",
+                ssh_data
+            )
+            logger.info(f"Reported SSH service: {ssh_response.status_code if hasattr(ssh_response, 'status_code') else ssh_response}")
+            
+        except Exception as e:
+            logger.error(f"Failed to report services: {e}", exc_info=True)
+    
+    def collect_metrics(self) -> dict:
+        """Collect system metrics"""
+        metrics = {}
+        
+        # CPU metrics
+        metrics['cpu'] = {
+            'percent': psutil.cpu_percent(interval=1),
+            'count': psutil.cpu_count(),
+            'timestamp': datetime.now(timezone.utc).isoformat()
+        }
+        
+        # Memory metrics
+        mem = psutil.virtual_memory()
+        metrics['ram'] = {
+            'total': mem.total,
+            'used': mem.used,
+            'available': mem.available,
+            'percent': mem.percent,
+            'timestamp': datetime.now(timezone.utc).isoformat()
+        }
+        
+        # GPU metrics (if available)
+        if HAS_GPU:
+            try:
+                gpus = GPUtil.getGPUs()
+                if gpus:
+                    gpu = gpus[0]
+                    metrics['gpu'] = {
+                        'name': gpu.name,
+                        'load': gpu.load * 100,
+                        'memory_used': gpu.memoryUsed,
+                        'memory_total': gpu.memoryTotal,
+                        'temperature': gpu.temperature,
+                        'timestamp': datetime.now(timezone.utc).isoformat()
+                    }
+            except Exception as e:
+                logger.debug(f"GPU metrics unavailable: {e}")
+        
+        return metrics
+    
+    def send_metrics(self):
+        """Send metrics to server"""
+        try:
+            metrics = self.collect_metrics()
+            
+            # Send CPU metrics
+            if 'cpu' in metrics:
+                self._post_device(f"/api/tunnel/agent/cpu/{self.device_id}/", metrics['cpu'])
+            
+            # Send RAM metrics  
+            if 'ram' in metrics:
+                self._post_device(f"/api/tunnel/agent/ram/{self.device_id}/", metrics['ram'])
+            
+            # Send GPU metrics if available
+            if 'gpu' in metrics and metrics['gpu']:
+                self._post_device(f"/api/tunnel/agent/gpu/{self.device_id}/", metrics['gpu'])
+            
+            logger.debug(f"Metrics sent - CPU: {metrics['cpu']['percent']:.1f}%, RAM: {metrics['ram']['percent']:.1f}%")
+            
+        except Exception as e:
+            logger.error(f"Failed to send metrics: {e}")
+    
+    def metrics_loop(self):
+        """Background thread for sending metrics"""
+        logger.info("Starting metrics thread")
+        
+        while self.running:
+            try:
+                self.send_metrics()
+                
+                # Check if processes are still running
+                if self.jupyter_proc and self.jupyter_proc.poll() is not None:
+                    logger.warning("Jupyter process died")
+                    self.jupyter_proc = None
+                
+                if self.tunnel_proc and self.tunnel_proc.poll() is not None:
+                    logger.warning("Tunnel process died")
+                    self.tunnel_proc = None
+                
+            except Exception as e:
+                logger.error(f"Metrics loop error: {e}")
+            
+            # Wait for next interval (default 5 seconds)
+            for _ in range(3):
+                if not self.running:
+                    break
+                time.sleep(1)
+        
+        logger.info("Metrics thread stopped")
+    
+    def run_device_agent(self):
+        """Main run method for device agent"""
+        logger.info("=" * 50)
+        logger.info("Starting Device Agent")
+        logger.info(f"Device ID: {self.device_id}")
+        logger.info(f"Server: {self.server_url}")
+        logger.info(f"Domain: {self.base_domain}")
+        logger.info("=" * 50)
+        
+        # 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)
+        
+        # Setup tunnels
+        if not self.setup_tunnels():
+            logger.error("Failed to setup tunnels")
+            self.cleanup_device_agent()
+            return
+        
+        # Print access information
+        logger.info("=" * 50)
+        logger.info("🎉 All services started successfully!")
+        logger.info(f"📔 Jupyter: {self.jupyter_url}")
+        logger.info(f"🔐 SSH: {self.ssh_url}")
+        # Remove https:// prefix for SSH command display
+        ssh_hostname = self.ssh_url.replace('https://', '')
+        import getpass
+        current_user = getpass.getuser()
+        logger.info(f"🔐 SSH Command: ssh -o ProxyCommand='cloudflared access ssh --hostname {ssh_hostname}' {current_user}@{ssh_hostname}")
+        logger.info("=" * 50)
+        
+        # Start metrics thread
+        self.metrics_thread = threading.Thread(target=self.metrics_loop, daemon=True)
+        self.metrics_thread.start()
+        
+        # Main loop
+        try:
+            while self.running:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            logger.info("Interrupted by user")
+        
+        self.cleanup_device_agent()
+    
+    def cleanup_device_agent(self):
+        """Clean up device agent resources"""
+        logger.info("Cleaning up...")
+        
+        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()
+        
+        logger.info("Cleanup complete")

unitlab/main.py

@@ -1,6 +1,8 @@
 from enum import Enum
 from pathlib import Path
 from uuid import UUID
+import logging
+import os
 
 import typer
 import validators
@@ -9,12 +11,16 @@ from typing_extensions import Annotated
 from . import utils
 from .client import UnitlabClient
 
+
 app = typer.Typer()
 project_app = typer.Typer()
 dataset_app = typer.Typer()
+agent_app = typer.Typer()
+
 
 app.add_typer(project_app, name="project", help="Project commands")
 app.add_typer(dataset_app, name="dataset", help="Dataset commands")
+app.add_typer(agent_app, name="agent", help="Agent commands")
 
 
 API_KEY = Annotated[
@@ -42,7 +48,7 @@ class AnnotationType(str, Enum):
 @app.command(help="Configure the credentials")
 def configure(
     api_key: Annotated[str, typer.Option(help="The api-key obtained from unitlab.ai")],
-    api_url: Annotated[str, typer.Option()] = "https://api.unitlab.ai",
+    api_url: Annotated[str, typer.Option()] = "https://localhost/",
 ):
     if not validators.url(api_url, simple_host=True):
         raise typer.BadParameter("Invalid api url")
@@ -105,5 +111,65 @@ def dataset_download(
     get_client(api_key).dataset_download_files(pk)
 
 
+def send_metrics_to_server(server_url: str, device_id: str, metrics: dict):
+    """Standalone function to send metrics to server using client"""
+    client = UnitlabClient(api_key="dummy")  # API key not needed for metrics
+    return client.send_metrics_to_server(server_url, device_id, metrics)
+
+
+def send_metrics_into_server():
+    """Standalone function to collect system metrics using client"""
+    client = UnitlabClient(api_key="dummy")  # API key not needed for metrics
+    return client.collect_system_metrics()
+
+
+@agent_app.command(name="run", help="Run the device agent with Jupyter, SSH tunnels and metrics")
+def run_agent(
+    api_key: str,
+    device_id: Annotated[str, typer.Option(help="Device ID")] = None,
+    base_domain: Annotated[str, typer.Option(help="Base domain for tunnels")] = "1scan.uz",
+  
+):
+    """Run the full device agent with Jupyter, SSH tunnels and metrics reporting"""
+    
+    # Setup logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s',
+        handlers=[logging.StreamHandler()]
+    )
+
+    # Get server URL from environment or use default
+    server_url = 'https://api-dev.unitlab.ai/'
+    
+    # Generate unique device ID if not provided
+    if not device_id:
+        import uuid
+        import platform
+        # Try environment variable first
+        device_id = os.getenv('DEVICE_ID')
+        if not device_id:
+            # Generate a unique ID based on hostname and random UUID
+            hostname = platform.node().replace('.', '-').replace(' ', '-')[:20]
+            random_suffix = str(uuid.uuid4())[:8]
+            device_id = f"{hostname}-{random_suffix}"
+          
+    
+    # Create client and initialize device agent
+    client = UnitlabClient(api_key=api_key)
+    client.initialize_device_agent(
+        server_url=server_url,
+        device_id=device_id,
+        base_domain=base_domain
+    )
+    
+    try:
+        client.run_device_agent()
+    except Exception as e:
+        logging.error(f"Fatal error: {e}")
+        client.cleanup_device_agent()
+        raise typer.Exit(1)
+
+
 if __name__ == "__main__":
     app()

unitlab/tunnel_config.py

@@ -0,0 +1,199 @@
+"""
+Cloudflare Tunnel Configuration using Service Token
+No user login required - uses pre-generated service token
+"""
+
+import os
+import subprocess
+import socket
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class CloudflareTunnel:
+    def __init__(self, base_domain, device_id):  # base_domain kept for compatibility
+        """
+        Initialize tunnel with service token
+        No login or credential files needed
+        """
+        # Configuration
+        self.base_domain = "1scan.uz"  # Hardcoded domain
+        self.device_id = device_id
+        self.hostname = socket.gethostname()
+        
+        # Service token - replace with your actual token from cloudflared tunnel token command
+        # This token can ONLY run the tunnel, cannot modify or delete it
+        # To generate: cloudflared tunnel token unitlab-shared
+        self.service_token = os.getenv(
+            "CLOUDFLARE_TUNNEL_TOKEN",
+            "eyJhIjoiYzkxMTkyYWUyMGE1ZDQzZjY1ZTA4NzU1MGQ4ZGM4OWIiLCJzIjoiZmdnSHowbFJFRnBHa05TZzIzV3JKMVBiaDVROGVUd0oyYWtJWThXdjhtTT0iLCJ0IjoiYjMzZGFhOGYtMmNjMy00Y2FkLWEyMjgtOTdlMDYwNzBlNjAwIn0="  # Replace this with your actual token from step 1
+        )
+        
+        if self.service_token == "YOUR_SERVICE_TOKEN_HERE":
+            logger.warning(
+                "⚠️  No service token configured. "
+                "Set CLOUDFLARE_TUNNEL_TOKEN env var or update the token in tunnel_config.py"
+            )
+        
+        # Subdomain names
+        self.jupyter_subdomain = f"jupyter-{device_id}"
+        self.ssh_subdomain = f"ssh-{device_id}"
+        
+        # Full URLs
+        self.jupyter_url = f"https://{self.jupyter_subdomain}.{self.base_domain}"
+        self.ssh_url = f"https://{self.ssh_subdomain}.{self.base_domain}"
+        
+        self.tunnel_process = None
+
+    def check_cloudflared_installed(self):
+        """Check if cloudflared is installed"""
+        try:
+            result = subprocess.run(
+                ["cloudflared", "--version"],
+                capture_output=True,
+                text=True
+            )
+            return result.returncode == 0
+        except FileNotFoundError:
+            return False
+
+    def install_cloudflared(self):
+        """Auto-install cloudflared if not present"""
+        import platform
+        
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+        
+        print("📦 Installing cloudflared...")
+        
+        try:
+            if system == "linux":
+                # Determine architecture
+                if machine in ["x86_64", "amd64"]:
+                    arch = "amd64"
+                elif machine in ["aarch64", "arm64"]:
+                    arch = "arm64"
+                else:
+                    arch = "386"
+                
+                # Download and install
+                url = f"https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-{arch}"
+                
+                commands = [
+                    f"curl -L {url} -o /tmp/cloudflared",
+                    "chmod +x /tmp/cloudflared",
+                    "sudo mv /tmp/cloudflared /usr/local/bin/cloudflared 2>/dev/null || "
+                    "mkdir -p ~/.local/bin && mv /tmp/cloudflared ~/.local/bin/cloudflared"
+                ]
+                
+                for cmd in commands:
+                    subprocess.run(cmd, shell=True, check=False)
+                
+                # Add ~/.local/bin to PATH if needed
+                local_bin = os.path.expanduser("~/.local/bin")
+                if local_bin not in os.environ.get("PATH", ""):
+                    os.environ["PATH"] = f"{local_bin}:{os.environ['PATH']}"
+                
+                return self.check_cloudflared_installed()
+                
+            elif system == "darwin":
+                # Try homebrew first
+                result = subprocess.run(["brew", "install", "cloudflared"], capture_output=True)
+                if result.returncode != 0:
+                    # Fallback to direct download
+                    url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64.tgz"
+                    subprocess.run(f"curl -L {url} | tar xz", shell=True)
+                    subprocess.run("sudo mv cloudflared /usr/local/bin/", shell=True)
+                
+                return self.check_cloudflared_installed()
+                
+            elif system == "windows":
+                print("⚠️  Please install cloudflared manually on Windows")
+                print("   Download from: https://github.com/cloudflare/cloudflared/releases")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Failed to install cloudflared: {e}")
+            return False
+
+    def setup(self, jupyter_port):  # jupyter_port kept for compatibility
+        """
+        Setup and start tunnel with service token
+        No login required!
+        """
+        print("🚀 Setting up Cloudflare tunnel with service token...")
+        
+        # Check if cloudflared is installed
+        if not self.check_cloudflared_installed():
+            print("cloudflared not found, attempting to install...")
+            if not self.install_cloudflared():
+                print("❌ Failed to install cloudflared. Please install it manually:")
+                print("   https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/")
+                return None
+        
+        # Start tunnel with service token
+        return self.start_tunnel_with_token()
+
+    def start_tunnel_with_token(self):
+        """
+        Start the tunnel using service token
+        This is much simpler than the credential file approach
+        """
+        try:
+            print("🚀 Starting Cloudflare tunnel...")
+            
+            # Simple command with service token
+            cmd = [
+                "cloudflared",
+                "tunnel",
+                "--no-autoupdate",  # Prevent auto-updates during run
+                "run",
+                "--token",
+                self.service_token
+            ]
+            
+            # Start the tunnel process
+            self.tunnel_process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1
+            )
+            
+            # Wait for tunnel to establish
+            print("⏳ Waiting for tunnel to connect...")
+            time.sleep(5)
+            
+            # Check if process is still running
+            if self.tunnel_process.poll() is None:
+                print("✅ Tunnel is running!")
+                print(f"📌 Jupyter URL: {self.jupyter_url}")
+                print(f"📌 SSH URL: {self.ssh_url}")
+                return self.tunnel_process
+            else:
+                # Read any error output
+                output = self.tunnel_process.stdout.read()
+                print("❌ Tunnel failed to start")
+                print(f"Error output: {output}")
+                return None
+                
+        except Exception as e:
+            print(f"❌ Error starting tunnel: {e}")
+            return None
+
+    def stop(self):
+        """Stop the tunnel if running"""
+        if self.tunnel_process and self.tunnel_process.poll() is None:
+            print("Stopping tunnel...")
+            self.tunnel_process.terminate()
+            self.tunnel_process.wait(timeout=5)
+            print("Tunnel stopped")
+
+    # Removed all the old methods that are no longer needed:
+    # - login() - not needed with service token
+    # - create_tunnel() - tunnel already exists
+    # - configure_dns() - already configured
+    # - create_config_file() - not needed with service token

unitlab/tunnel_service_token.py

@@ -0,0 +1,104 @@
+"""
+Service Token implementation for Cloudflare Tunnel
+More secure than embedding full credentials
+"""
+
+import os
+import subprocess
+import time
+from pathlib import Path
+
+
+class ServiceTokenTunnel:
+    """
+    Use Cloudflare Service Token instead of credentials file
+    This is more secure and doesn't require login
+    """
+    
+    # Embed the service token (generated once by admin)
+    # This token can ONLY run the tunnel, cannot modify it
+    DEFAULT_SERVICE_TOKEN = "eyJhIjoiYzkxMTkyYWUyMGE1ZDQzZjY1ZTA4NzU1MGQ4ZGM4OWIiLCJzIjoiZmdnSHowbFJFRnBHa05TZzIzV3JKMVBiaDVROGVUd0oyYWtJWThXdjhtTT0iLCJ0IjoiYjMzZGFhOGYtMmNjMy00Y2FkLWEyMjgtOTdlMDYwNzBlNjAwIn0="
+    
+    def __init__(self, device_id, service_token=None):
+        self.device_id = device_id
+        # Allow override via environment variable or parameter
+        self.service_token = (
+            service_token or 
+            os.getenv("CLOUDFLARE_TUNNEL_TOKEN") or 
+            self.DEFAULT_SERVICE_TOKEN
+        )
+        
+        # With service token, we don't need credential files
+        # The token contains all necessary information
+        
+    def start_tunnel_with_token(self):
+        """
+        Start tunnel using service token
+        No login, no credential files needed
+        """
+        print("🚀 Starting tunnel with service token...")
+        
+        # Service token method - super simple!
+        cmd = [
+            "cloudflared", 
+            "tunnel", 
+            "run",
+            "--token",
+            self.service_token
+        ]
+        
+        try:
+            # Start the tunnel
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            # Wait for tunnel to establish
+            time.sleep(3)
+            
+            if process.poll() is None:
+                print("✅ Tunnel running with service token")
+                return process
+            else:
+                print("❌ Failed to start tunnel")
+                return None
+                
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            return None
+    
+    def get_tunnel_info(self):
+        """
+        Service tokens use predetermined URLs
+        The admin sets these up when creating the tunnel
+        """
+        # These URLs are configured when creating the tunnel
+        base_domain = "1scan.uz"
+        return {
+            "jupyter_url": f"https://jupyter-{self.device_id}.{base_domain}",
+            "ssh_url": f"https://ssh-{self.device_id}.{base_domain}"
+        }
+
+
+# Usage example
+def run_with_service_token(device_id):
+    """
+    Example of how simple it is with service token
+    """
+    tunnel = ServiceTokenTunnel(device_id)
+    
+    # No login needed!
+    # No credential files needed!
+    # Just run with the token
+    process = tunnel.start_tunnel_with_token()
+    
+    if process:
+        urls = tunnel.get_tunnel_info()
+        print(f"Jupyter: {urls['jupyter_url']}")
+        print(f"SSH: {urls['ssh_url']}")
+        return process
+    
+    return None

unitlab/utils.py

@@ -1,6 +1,8 @@
 import logging
 from configparser import ConfigParser
 from pathlib import Path
+import logging
+import requests
 
 import requests
 
@@ -63,3 +65,4 @@ def get_api_url() -> str:
         return config.get("default", "api_url")
     except Exception:
         return "https://api.unitlab.ai"
+

{unitlab-2.3.0.dist-info → unitlab-2.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: unitlab
-Version: 2.3.0
+Version: 2.3.4
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai
@@ -21,11 +21,7 @@ Requires-Dist: requests
 Requires-Dist: tqdm
 Requires-Dist: typer
 Requires-Dist: validators
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
+Requires-Dist: psutil
+Requires-Dist: pyyaml
+Requires-Dist: jupyter
+

unitlab-2.3.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
+unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
+unitlab/client.py,sha256=LGbjto3jisF5LojlYjJyLKRc55wxfZTO_tkoipZBKd4,22910
+unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
+unitlab/main.py,sha256=XD8PF_EJ1gAKqHcRT_bWy62LWrODGWMx2roKoaQaoY4,5253
+unitlab/tunnel_config.py,sha256=WhxjuOjvOXz16KbMAgpvbCpRD0Y5y53y9jVizQ7CxR8,7841
+unitlab/tunnel_service_token.py,sha256=ji96a4s4W2cFJrHZle0zBD85Ac_T862-gCKzBUomrxM,3125
+unitlab/utils.py,sha256=83ekAxxfXecFTg76Z62BGDybC_skKJHYoLyawCD9wGM,1920
+unitlab-2.3.4.dist-info/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
+unitlab-2.3.4.dist-info/METADATA,sha256=4GHYHBRrtcbbHw06gcZ5mfucnjJvOGFC4Y8DvRqw-28,814
+unitlab-2.3.4.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+unitlab-2.3.4.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
+unitlab-2.3.4.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
+unitlab-2.3.4.dist-info/RECORD,,

{unitlab-2.3.0.dist-info → unitlab-2.3.4.dist-info}/WHEEL

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

unitlab-2.3.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
-unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-unitlab/client.py,sha256=j8m0An4Bt3ARA1ps7P2o-NLcfWFPoaXG_PxIdBDAEpQ,8374
-unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
-unitlab/main.py,sha256=3_awGLQ39dOA4WpOLkngzTK1X9ttOs9avh4PvJFlH34,3039
-unitlab/utils.py,sha256=U95JqeUvKP0p5Ka0KIar0e8Uqe_4TZmZ7N68UdEGfpk,1888
-unitlab-2.3.0.dist-info/licenses/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
-unitlab-2.3.0.dist-info/METADATA,sha256=9gk8MoNLgV1jPR9TdT_NSvM8wqAqxU10isgBNjQzgNY,903
-unitlab-2.3.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-unitlab-2.3.0.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
-unitlab-2.3.0.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
-unitlab-2.3.0.dist-info/RECORD,,