Update lib.py

lib.py

@@ -1,1253 +1,16 @@
-import uuid
-import time
-import sys
-import subprocess
-import os
-import io
-import tempfile
-import threading
-import platform
-import urllib.request
-import tarfile
-from typing import Dict, List, Optional, Tuple
-
-def detect_linux_distro():
-    """Detect Linux distribution and package manager"""
-    try:
-        with open('/etc/os-release', 'r') as f:
-            content = f.read().lower()
-
-        if 'ubuntu' in content or 'debian' in content:
-            return 'debian', 'apt'
-        elif 'fedora' in content:
-            return 'fedora', 'dnf'
-        elif 'centos' in content or 'rhel' in content:
-            return 'centos', 'yum'
-        elif 'opensuse' in content or 'sles' in content:
-            return 'opensuse', 'zypper'
-        elif 'arch' in content:
-            return 'arch', 'pacman'
-        elif 'alpine' in content:
-            return 'alpine', 'apk'
-        else:
-            return 'unknown', 'unknown'
-    except:
-        return 'unknown', 'unknown'
-
-def run_with_sudo(cmd):
-    """Run command with sudo if available, otherwise try without"""
-    try:
-        # Try with sudo first
-        result = subprocess.run(['sudo'] + cmd, capture_output=True, text=True, timeout=60)
-        if result.returncode == 0:
-            return True, result.stdout, result.stderr
-        else:
-            # Try without sudo
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-            return result.returncode == 0, result.stdout, result.stderr
-    except:
-        # Try without sudo
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-        return result.returncode == 0, result.stdout, result.stderr
-
-def install_podman_comprehensive():
-    """Comprehensive podman installation with 200+ edge cases handled"""
-    print("🛠️  Starting comprehensive podman installation...")
-
-    distro, package_manager = detect_linux_distro()
-    print(f"📋 Detected: {distro} with {package_manager}")
-
-    installation_methods = [
-        # Method 1: Standard package manager installation
-        lambda: install_via_package_manager(distro, package_manager),
-
-        # Method 2: Download static binary (no dependencies)
-        lambda: install_podman_static_binary(),
-
-        # Method 3: Try different package names
-        lambda: install_via_alternative_packages(),
-
-        # Method 4: Install from source (last resort)
-        lambda: install_podman_from_source(),
-    ]
-
-    for i, install_method in enumerate(installation_methods, 1):
-        print(f"\n🔄 Attempting installation method {i}/4...")
-        try:
-            if install_method():
-                print("✅ Podman installation successful!")
-                return True
-        except Exception as e:
-            print(f"❌ Method {i} failed: {e}")
-            continue
-
-    print("💥 All installation methods failed. Please install podman manually.")
-    return False
-
-def install_via_package_manager(distro, package_manager):
-    """Install podman via system package manager"""
-    print(f"📦 Installing via {package_manager}...")
-
-    # Update package lists first
-    if package_manager == 'apt':
-        run_with_sudo(['apt', 'update', '-qq'])
-        packages = ['podman', 'podman-docker', 'uidmap', 'slirp4netns']
-        cmd = ['apt', 'install', '-y', '-qq'] + packages
-    elif package_manager == 'dnf':
-        run_with_sudo(['dnf', 'check-update', '-q'])
-        packages = ['podman', 'podman-docker', 'shadow-utils', 'slirp4netns']
-        cmd = ['dnf', 'install', '-y', '-q'] + packages
-    elif package_manager == 'yum':
-        run_with_sudo(['yum', 'check-update', '-q'])
-        packages = ['podman', 'podman-docker', 'shadow-utils', 'slirp4netns']
-        cmd = ['yum', 'install', '-y', '-q'] + packages
-    elif package_manager == 'zypper':
-        run_with_sudo(['zypper', 'refresh', '-q'])
-        packages = ['podman', 'podman-docker', 'shadow', 'slirp4netns']
-        cmd = ['zypper', 'install', '-y', '-q'] + packages
-    elif package_manager == 'pacman':
-        run_with_sudo(['pacman', '-Sy', '--quiet'])
-        packages = ['podman', 'podman-docker', 'shadow', 'slirp4netns']
-        cmd = ['pacman', '-S', '--noconfirm', '--quiet'] + packages
-    elif package_manager == 'apk':
-        packages = ['podman', 'podman-docker', 'shadow', 'slirp4netns']
-        cmd = ['apk', 'add'] + packages
-    else:
-        return False
-
-    success, stdout, stderr = run_with_sudo(cmd)
-    if success:
-        # Configure podman for rootless operation
-        configure_podman_rootless()
-        return verify_podman_installation()
-    else:
-        print(f"Package installation failed: {stderr}")
-        return False
-
-def install_podman_static_binary():
-    """Install podman static binary (no dependencies)"""
-    print("📥 Installing podman static binary...")
-
-    try:
-        home_bin = os.path.expanduser("~/bin")
-        os.makedirs(home_bin, exist_ok=True)
-
-        # Update PATH
-        current_path = os.environ.get('PATH', '')
-        if home_bin not in current_path:
-            os.environ['PATH'] = f"{home_bin}:{current_path}"
-
-        # Try multiple download URLs
-        urls = [
-            "https://github.com/containers/podman/releases/latest/download/podman-remote-static-linux_amd64.tar.gz",
-            "https://github.com/containers/podman/releases/download/v4.8.3/podman-remote-static-linux_amd64.tar.gz",
-            "https://github.com/containers/podman/releases/download/v4.7.2/podman-remote-static-linux_amd64.tar.gz",
-        ]
-
-        for url in urls:
-            try:
-                print(f"Downloading from {url}...")
-                with tempfile.NamedTemporaryFile(suffix='.tar.gz', delete=False) as tmp_file:
-                    urllib.request.urlretrieve(url, tmp_file.name, timeout=30)
-
-                    with tarfile.open(tmp_file.name, 'r:gz') as tar:
-                        for member in tar.getmembers():
-                            if member.name.endswith('/podman') or member.name.endswith('/podman-remote'):
-                                tar.extract(member, home_bin)
-                                extracted_path = os.path.join(home_bin, os.path.basename(member.name))
-                                os.chmod(extracted_path, 0o755)
-                                break
-
-                os.unlink(tmp_file.name)
-                break
-            except Exception as e:
-                print(f"Failed to download from {url}: {e}")
-                continue
-
-        return verify_podman_installation()
-
-    except Exception as e:
-        print(f"Static binary installation failed: {e}")
-        return False
-
-def install_via_alternative_packages():
-    """Try alternative package names and installation methods"""
-    print("🔄 Trying alternative installation methods...")
-
-    alternatives = [
-        # Try different package names
-        (['apt', 'install', '-y', 'podman-compose', 'podman'], 'debian'),
-        (['dnf', 'install', '-y', 'podman-compose'], 'fedora'),
-        (['yum', 'install', '-y', 'podman-compose'], 'centos'),
-
-        # Try snap (if available)
-        (['snap', 'install', 'podman', '--classic'], 'any'),
-
-        # Try flatpak (if available)
-        (['flatpak', 'install', '-y', 'flathub', 'io.podman_desktop.Podman'], 'any'),
-    ]
-
-    for cmd, distro_check in alternatives:
-        try:
-            success, stdout, stderr = run_with_sudo(cmd)
-            if success:
-                print(f"Alternative installation successful with {cmd[0]}")
-                return verify_podman_installation()
-        except:
-            continue
-
-    return False
-
-def install_podman_from_source():
-    """Install podman from source (last resort)"""
-    print("🏗️  Installing podman from source (this may take a while)...")
-
-    try:
-        # This is complex and requires Go, so let's just try a simpler approach
-        # We'll download a pre-compiled version from a known working source
-        print("Source installation is complex. Trying simpler approach...")
-
-        # Try to install via conda if available
-        try:
-            success, stdout, stderr = run_with_sudo(['conda', 'install', '-y', '-c', 'conda-forge', 'podman'])
-            if success:
-                return verify_podman_installation()
-        except:
-            pass
-
-        # Try via pip (podman python package)
-        try:
-            success, stdout, stderr = run_with_sudo(['pip3', 'install', 'podman'])
-            if success:
-                return verify_podman_installation()
-        except:
-            pass
-
-        return False
-
-    except Exception as e:
-        print(f"Source installation failed: {e}")
-        return False
-
-def configure_podman_rootless():
-    """Configure podman for rootless operation"""
-    try:
-        # Enable unprivileged user namespaces
-        run_with_sudo(['sysctl', 'kernel.unprivileged_userns_clone=1'])
-
-        # Create podman configuration
-        config_dir = os.path.expanduser("~/.config/containers")
-        os.makedirs(config_dir, exist_ok=True)
-
-        # Basic registries.conf
-        registries_content = """[registries.search]
-registries = ['docker.io', 'quay.io']
-
-[registries.insecure]
-registries = []
-
-[registries.block]
-registries = []
-"""
-
-        with open(os.path.join(config_dir, 'registries.conf'), 'w') as f:
-            f.write(registries_content)
-
-    except Exception as e:
-        print(f"Podman configuration warning: {e}")
-
-def verify_podman_installation():
-    """Verify that podman was installed successfully"""
-    try:
-        result = subprocess.run(['podman', '--version'], capture_output=True, text=True, timeout=10)
-        if result.returncode == 0:
-            version = result.stdout.strip()
-            print(f"✅ Podman verified: {version}")
-
-            # Test basic functionality
-            result = subprocess.run(['podman', 'info'], capture_output=True, text=True, timeout=15)
-            if result.returncode == 0:
-                print("✅ Podman info command works")
-                return True
-            else:
-                print(f"⚠️  Podman info failed: {result.stderr}")
-                return True  # Still consider it installed
-        else:
-            print(f"❌ Podman verification failed: {result.stderr}")
-            return False
-    except Exception as e:
-        print(f"❌ Podman verification error: {e}")
-        return False
-
-def install_podman_linux():
-    """Main entry point for podman installation"""
-    return install_podman_comprehensive()
-
-def run_podman_cmd(cmd_args: List[str]) -> Tuple[bool, str, str]:
-    try:
-        cmd = ['podman'] + cmd_args
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
-        return result.returncode == 0, result.stdout, result.stderr
-    except FileNotFoundError:
-        # Try to install podman on Linux if not found
-        if platform.system() == 'Linux':
-            print("Podman not found, attempting automatic installation...")
-            if install_podman_linux():
-                # Try the command again after installation
-                cmd = ['podman'] + cmd_args
-                result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
-                return result.returncode == 0, result.stdout, result.stderr
-            else:
-                return False, "", "Podman not found and automatic installation failed. Please install podman manually."
-        else:
-            return False, "", "Podman not found. Please install podman and ensure it's in your PATH. On Linux: 'sudo apt install podman' or 'sudo dnf install podman'"
-    except subprocess.TimeoutExpired:
-        return False, "", "Command timed out"
-    except Exception as e:
-        return False, "", f"Error executing podman command: {e}"
-
-def copy_file_to_container(container_name: str, local_path: str, container_path: str) -> bool:
-    try:
-        cmd = ['podman', 'cp', local_path, f"{container_name}:{container_path}"]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        return result.returncode == 0
-    except Exception as e:
-        print(f"Error copying file to container: {e}")
-        return False
-
-def copy_file_from_container(container_name: str, container_path: str, local_path: str) -> bool:
-    try:
-        cmd = ['podman', 'cp', f"{container_name}:{container_path}", local_path]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        return result.returncode == 0
-    except Exception as e:
-        print(f"Error copying file from container: {e}")
-        return False
-
-def run_command_in_container(container_name: str, command: str, workdir: Optional[str] = None) -> Tuple[bool, str, str]:
-    try:
-        cmd = ['podman', 'exec']
-        if workdir:
-            cmd.extend(['-w', workdir])
-        cmd.extend([container_name, 'bash', '-c', command])
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-        return result.returncode == 0, result.stdout, result.stderr
-    except subprocess.TimeoutExpired:
-        return False, "", "Command execution timed out"
-    except Exception as e:
-        return False, "", f"Error executing command in container: {e}"
-
-def run_python_code_streaming(container_name: str, code: str, workdir: Optional[str] = None):
-    try:
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
-            f.write(code)
-            temp_file = f.name
-
-        temp_container_path = f'/tmp/python_script_{uuid.uuid4().hex[:8]}.py'
-        success = copy_file_to_container(container_name, temp_file, temp_container_path)
-
-        os.unlink(temp_file)
-
-        if not success:
-            yield "Error: Failed to copy Python file to container\n"
-            return
-
-        check_cmd = ['podman', 'exec', container_name, 'which', 'python']
-        check_result = subprocess.run(check_cmd, capture_output=True, text=True, timeout=10)
-        python_command = 'python'
-        if check_result.returncode != 0:
-            check_cmd3 = ['podman', 'exec', container_name, 'which', 'python3']
-            check_result3 = subprocess.run(check_cmd3, capture_output=True, text=True, timeout=10)
-            if check_result3.returncode == 0:
-                python_command = 'python3'
-            else:
-                yield "Warning: python not found in container PATH, searching...\n"
-                find_cmd = ['podman', 'exec', container_name, 'bash', '-c', 'find /usr -name python -o -name python3 -type f 2>/dev/null | head -1']
-                find_result = subprocess.run(find_cmd, capture_output=True, text=True, timeout=10)
-                if find_result.returncode == 0 and find_result.stdout.strip():
-                    python_command = find_result.stdout.strip()
-                    yield f"Found python at: {python_command}\n"
-                else:
-                    yield "Error: Could not locate python in container\n"
-                    return
-
-        cmd = ['podman', 'exec']
-        if workdir:
-            cmd.extend(['-w', workdir])
-        cmd.extend([container_name, 'bash', '-c', f'{python_command} "{temp_container_path}" 2>&1'])
-
-        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)
-
-        try:
-            for line in iter(process.stdout.readline, ''):
-                if line:
-                    yield line
-        except Exception as e:
-            yield f"Error reading output: {e}\n"
-        finally:
-            process.stdout.close()
-            process.wait()
-
-            run_podman_cmd(['exec', container_name, 'rm', '-f', temp_container_path])
-
-    except Exception as e:
-        yield f"Error executing Python code: {e}\n"
-
-def run_lua_code_streaming(container_name: str, code: str, workdir: Optional[str] = None):
-    try:
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.lua', delete=False) as f:
-            f.write(code)
-            temp_file = f.name
-
-        temp_container_path = f'/tmp/lua_script_{uuid.uuid4().hex[:8]}.lua'
-        success = copy_file_to_container(container_name, temp_file, temp_container_path)
-
-        os.unlink(temp_file)
-
-        if not success:
-            yield "Error: Failed to copy Lua file to container\n"
-            return
-
-        lua_executables = ['lua', 'lua5.4', 'lua5.3', 'lua5.2', 'lua5.1']
-        lua_command = None
-
-        for exe in lua_executables:
-            check_cmd = ['podman', 'exec', container_name, 'which', exe]
-            check_result = subprocess.run(check_cmd, capture_output=True, text=True, timeout=10)
-            if check_result.returncode == 0:
-                lua_command = exe
-                break
-
-        if not lua_command:
-            yield "Warning: No lua executable found in container PATH, searching filesystem...\n"
-            find_cmd = ['podman', 'exec', container_name, 'bash', '-c', 'find /usr/local/bin /usr/bin -name "lua*" -type f 2>/dev/null | head -1']
-            find_result = subprocess.run(find_cmd, capture_output=True, text=True, timeout=10)
-            if find_result.returncode == 0 and find_result.stdout.strip():
-                lua_command = find_result.stdout.strip()
-                yield f"Found lua at: {lua_command}\n"
-            else:
-                yield "Error: Could not locate lua in container\n"
-                return
-
-        cmd = ['podman', 'exec']
-        if workdir:
-            cmd.extend(['-w', workdir])
-        cmd.extend([container_name, 'bash', '-c', f'{lua_command} "{temp_container_path}" 2>&1'])
-
-        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)
-
-        try:
-            for line in iter(process.stdout.readline, ''):
-                if line:
-                    yield line
-        except Exception as e:
-            yield f"Error reading output: {e}\n"
-        finally:
-            process.stdout.close()
-            process.wait()
-
-            run_podman_cmd(['exec', container_name, 'rm', '-f', temp_container_path])
-
-    except Exception as e:
-        yield f"Error executing Lua code: {e}\n"
-
-try:
-    from flask import Flask, request, jsonify
-    FLASK_AVAILABLE = True
-except ImportError:
-    FLASK_AVAILABLE = False
-
-def install_package(package_name: str):
-    try:
-        print(f"Installing {package_name}...")
-        import subprocess
-        cmd = [sys.executable, "-m", "pip", "install", package_name]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        if result.returncode == 0:
-            print(f"Successfully installed {package_name}")
-            return True
-        else:
-            print(f"Failed to install {package_name}: {result.stderr}")
-            return False
-    except Exception as e:
-        print(f"Error installing {package_name}: {e}")
-        return False
-
-if not FLASK_AVAILABLE:
-    print("Flask not found, attempting to install...")
-    if install_package("flask"):
-        try:
-            from flask import Flask, request, jsonify
-            FLASK_AVAILABLE = True
-        except ImportError:
-            FLASK_AVAILABLE = False
-
-if FLASK_AVAILABLE:
-    from flask_cors import CORS
-    app = Flask(__name__)
-    CORS(app)
-
-    class VMManager:
-        def __init__(self):
-            self.vms = {}
-            self.cleanup_interval = 60
-            self.max_idle_time = 180
-            self.cleanup_thread = None
-            self.lua_vm_id = None
-            self._cleanup_running = False
-            self._start_cleanup_thread()
-
-        def _start_cleanup_thread(self):
-            if self.cleanup_thread is None or not self.cleanup_thread.is_alive():
-                self.cleanup_thread = threading.Thread(target=self._cleanup_worker, daemon=True)
-                self.cleanup_thread.start()
-
-        def _cleanup_worker(self):
-            while True:
-                try:
-                    # Only run cleanup if not already running
-                    if not self._cleanup_running:
-                        self._cleanup_running = True
-                        try:
-                            self._perform_cleanup()
-                        finally:
-                            self._cleanup_running = False
-
-                except Exception as e:
-                    print(f"Error in cleanup worker: {e}")
-                    self._cleanup_running = False
-
-                time.sleep(self.cleanup_interval)
-
-        def _perform_cleanup(self):
-            """Perform the actual cleanup logic (used by both auto and manual cleanup)"""
-            current_time = time.time()
-            cleanup_threshold = 180  # 3 minutes for automatic cleanup
-            deleted_count = 0
-            orphaned_containers_deleted = 0
-
-            print(f"Automatic cleanup: checking for idle VMs and orphaned containers...")
-
-            vms_to_delete = []
-            for vm_id, vm in self.vms.items():
-                if vm_id == self.lua_vm_id:
-                    continue
-                if current_time - vm.get('last_used', vm['created']) > cleanup_threshold:
-                    vms_to_delete.append(vm_id)
-
-            for vm_id in vms_to_delete:
-                age_minutes = round((current_time - self.vms[vm_id].get('last_used', self.vms[vm_id]['created'])) / 60, 1)
-                print(f"Auto-deleting idle VM {vm_id} (unused for {age_minutes} minutes)")
-                self.delete_vm(vm_id)
-                deleted_count += 1
-
-            # Clean up orphaned podman containers
-            try:
-                ps_success, ps_stdout, ps_stderr = run_podman_cmd(['ps', '-a', '--filter', 'name=vm-', '--format', 'json'])
-                if ps_success and ps_stdout:
-                    try:
-                        import json as json_lib
-                        containers = json_lib.loads(ps_stdout)
-                        if isinstance(containers, list):
-                            for container in containers:
-                                container_name = container.get('Names', [''])[0] if container.get('Names') else ''
-                                if container_name.startswith('vm-'):
-                                    vm_id = container_name[3:]  # Remove 'vm-' prefix
-                                    if vm_id not in self.vms:
-                                        print(f"Auto-deleting orphaned container {container_name}")
-                                        run_podman_cmd(['rm', '-f', container_name])
-                                        orphaned_containers_deleted += 1
-                    except Exception as e:
-                        print(f"Error parsing container list in auto cleanup: {e}")
-            except Exception as e:
-                print(f"Error checking for orphaned containers in auto cleanup: {e}")
-
-            if deleted_count > 0 or orphaned_containers_deleted > 0:
-                print(f"Automatic cleanup completed: deleted {deleted_count} VMs and {orphaned_containers_deleted} orphaned containers")
-            else:
-                print("Automatic cleanup completed: nothing to clean")
-
-        def _update_last_used(self, vm_id):
-            if vm_id in self.vms:
-                self.vms[vm_id]['last_used'] = time.time()
-
-        def _ensure_lua_vm(self):
-            if self.lua_vm_id and self.lua_vm_id in self.vms:
-                vm = self.vms[self.lua_vm_id]
-                if vm.get('status') == 'running':
-                    return self.lua_vm_id
-
-            print("Creating persistent Lua VM...")
-            self.lua_vm_id = self.create_vm(
-                vcpu=0.25,
-                memory="512m",
-                image="debian:latest",
-                install_python=False
-            )
-
-            if self.lua_vm_id:
-                print(f"Created persistent Lua VM: {self.lua_vm_id}")
-                self._install_lua_in_persistent_vm(self.lua_vm_id)
-
-            return self.lua_vm_id
-
-        def create_vm(self, vcpu=1, memory="512m", image="debian:latest", install_python=True):
-            vm_id = str(uuid.uuid4())[:8]
-            container_name = f"vm-{vm_id}"
-
-            # Try different container creation approaches for different environments
-            success, stdout, stderr = run_podman_cmd([
-                'run', '-d', '--name', container_name,
-                '--cpus', str(vcpu), '--memory', memory,
-                '--rm', image, 'sleep', 'infinity'
-            ])
-
-            # If rootless podman fails, try with different options
-            if not success:
-                print(f"Initial container creation failed: {stderr}")
-
-                # Check if we're in a containerized environment
-                if os.path.exists('/.dockerenv') or os.path.exists('/run/.containerenv'):
-                    print("Detected containerized environment, trying alternative podman configuration...")
-
-                    # Try with --privileged flag for podman
-                    success, stdout, stderr = run_podman_cmd([
-                        '--runtime', 'runc', 'run', '-d', '--name', container_name,
-                        '--cpus', str(vcpu), '--memory', memory,
-                        '--rm', image, 'sleep', 'infinity'
-                    ])
-
-                    if not success:
-                        # Try with crun runtime if available
-                        success, stdout, stderr = run_podman_cmd([
-                            '--runtime', 'crun', 'run', '-d', '--name', container_name,
-                            '--cpus', str(vcpu), '--memory', memory,
-                            '--rm', image, 'sleep', 'infinity'
-                        ])
-
-                if not success:
-                    print(f"Failed to create container after retries: {stderr}")
-                    if "authentication required" in stderr.lower():
-                        print("Podman authentication issue. Try running: podman login docker.io")
-                    elif "podman not found" in stderr.lower():
-                        print("Podman not installed. Install with: sudo apt install podman")
-                    elif "namespace" in stderr.lower() or "newuidmap" in stderr.lower():
-                        print("Rootless podman issue. Container needs privileged mode or proper user namespace setup.")
-                        print("Try running container with: --privileged --cap-add=SYS_ADMIN")
-                    elif "shared mount" in stderr.lower():
-                        print("Mount sharing issue. Try running container with: --mount type=tmpfs,destination=/tmp")
-                    return None
-
-            self.vms[vm_id] = {
-                'container_name': container_name,
-                'vcpu': vcpu,
-                'memory': memory,
-                'created': time.time(),
-                'last_used': time.time(),
-                'commands': [],
-                'cwd': '/'  # Default working directory
-            }
-
-            if 'debian' in image.lower() or 'ubuntu' in image.lower():
-                if install_python:
-                    self._install_python_in_vm(vm_id)
-                self._install_lua_in_vm(vm_id)
-            elif 'alpine' in image.lower():
-                self._install_lua_in_vm(vm_id)
-
-            return vm_id
-
-        def _install_python_in_vm(self, vm_id):
-            if vm_id not in self.vms:
-                return
-
-            container_name = self.vms[vm_id]['container_name']
-
-            update_success, update_stdout, update_stderr = run_podman_cmd(['exec', container_name, 'apt-get', 'update', '-qq'])
-            if not update_success:
-                print(f"Warning: Failed to update package lists for VM {vm_id}: {update_stderr}")
-
-            python_success, python_stdout, python_stderr = run_podman_cmd(['exec', container_name, 'apt-get', 'install', '-y', 'python3', 'python3-pip'])
-            if not python_success:
-                print(f"Warning: Failed to install Python for VM {vm_id}: {python_stderr}")
-                alt_success, alt_stdout, alt_stderr = run_podman_cmd(['exec', container_name, 'apt-get', 'install', '-y', 'python3-minimal'])
-                if not alt_success:
-                    print(f"Warning: Failed to install python3-minimal for VM {vm_id}: {alt_stderr}")
-                else:
-                    print(f"Successfully installed python3-minimal for VM {vm_id}")
-            else:
-                print(f"Successfully installed Python3 and pip for VM {vm_id}")
-
-            verify_success, verify_stdout, verify_stderr = run_podman_cmd(['exec', container_name, 'python3', '--version'])
-            if verify_success:
-                print(f"Python verification successful for VM {vm_id}: {verify_stdout.strip()}")
-            else:
-                print(f"Warning: Python verification failed for VM {vm_id}: {verify_stderr}")
-
-        def _install_lua_in_vm(self, vm_id):
-            if vm_id not in self.vms:
-                return
-
-            container_name = self.vms[vm_id]['container_name']
-
-            print(f"Installing Lua for VM {vm_id}...")
-
-            lua_install_success, lua_install_stdout, lua_install_stderr = run_podman_cmd([
-                'exec', container_name, 'apk', 'add', '--no-cache', 'lua5.4'
-            ])
-
-            if not lua_install_success:
-                print(f"Warning: Failed to install Lua for VM {vm_id}: {lua_install_stderr}")
-                return
-
-            print(f"Successfully installed Lua 5.4 for VM {vm_id}")
-
-            verify_success, verify_stdout, verify_stderr = run_podman_cmd(['exec', container_name, 'lua5.4', '--version'])
-            if verify_success:
-                print(f"Lua verification successful for VM {vm_id}: {verify_stdout.strip()}")
-            else:
-                print(f"Warning: Lua verification failed for VM {vm_id}: {verify_stderr}")
-                print("Checking what Lua executables are available...")
-                which_success, which_stdout, which_stderr = run_podman_cmd(['exec', container_name, 'find', '/usr/bin', '-name', 'lua*', '-type', 'f'])
-                if which_success and which_stdout.strip():
-                    print(f"Found Lua executables: {which_stdout.strip()}")
-                else:
-                    print("No Lua executables found in /usr/bin")
-
-        def _install_lua_in_persistent_vm(self, vm_id):
-            if vm_id not in self.vms:
-                return
-
-            container_name = self.vms[vm_id]['container_name']
-
-            print(f"Installing Lua in persistent VM {vm_id}...")
-
-            update_success, update_stdout, update_stderr = run_podman_cmd(['exec', container_name, 'apt-get', 'update', '-qq'])
-            if not update_success:
-                print(f"Warning: Failed to update package lists for Lua installation in persistent VM {vm_id}: {update_stderr}")
-
-            build_deps_success, build_deps_stdout, build_deps_stderr = run_podman_cmd([
-                'exec', container_name, 'apt-get', 'install', '-y', '-qq',
-                'curl', 'build-essential', 'libreadline-dev'
-            ])
-            if not build_deps_success:
-                print(f"Warning: Failed to install build dependencies for persistent VM {vm_id}: {build_deps_stderr}")
-                return
-
-            print(f"Downloading and compiling Lua in persistent VM {vm_id}...")
-            lua_install_cmd = '''
-                cd /tmp && \
-                curl -L -o lua.tar.gz http://www.lua.org/ftp/lua-5.4.6.tar.gz && \
-                tar zxf lua.tar.gz && \
-                cd lua-5.4.6 && \
-                make linux && \
-                make install && \
-                cd /tmp && \
-                rm -rf lua-5.4.6 lua.tar.gz
-            '''.strip()
-
-            install_success, install_stdout, install_stderr = run_podman_cmd([
-                'exec', container_name, 'bash', '-c', lua_install_cmd
-            ])
-
-            if not install_success:
-                print(f"Warning: Failed to compile/install Lua in persistent VM {vm_id}: {install_stderr}")
-                return
-
-            verify_success, verify_stdout, verify_stderr = run_podman_cmd(['exec', container_name, 'lua', '--version'])
-            if verify_success:
-                print(f"Lua verification successful in persistent VM {vm_id}: {verify_stdout.strip()}")
-            else:
-                print(f"Warning: Lua verification failed in persistent VM {vm_id}: {verify_stderr}")
-
-        def run_command(self, vm_id, command, workdir=None):
-            if vm_id not in self.vms:
-                return None
-
-            self._update_last_used(vm_id)
-            vm = self.vms[vm_id]
-            container_name = vm['container_name']
-
-            command_stripped = command.strip()
-            if command_stripped == 'cd' or command_stripped.startswith('cd '):
-                if command_stripped == 'cd':
-                    vm['cwd'] = '/root'
-                    result = "Changed directory to /root"
-                else:
-                    new_dir = command_stripped[3:].strip()
-                    if new_dir:
-                        if not new_dir.startswith('/'):
-                            new_dir = os.path.join(vm['cwd'], new_dir)
-                        new_dir = os.path.normpath(new_dir)
-                        test_cmd = f'test -d "{new_dir}" && echo "DIR_EXISTS" || echo "DIR_NOT_FOUND"'
-                        success, stdout, stderr = run_command_in_container(container_name, test_cmd, vm['cwd'])
-                        if success and 'DIR_EXISTS' in stdout:
-                            vm['cwd'] = new_dir
-                            result = f"Changed directory to {new_dir}"
-                        else:
-                            result = f"cd: {new_dir}: No such file or directory"
-                    else:
-                        vm['cwd'] = '/root'
-                        result = "Changed directory to /root"
-            else:
-                current_workdir = workdir if workdir is not None else vm['cwd']
-
-                success, stdout, stderr = run_command_in_container(container_name, command, current_workdir)
-
-                if success:
-                    result = stdout.rstrip() if stdout else ""
-                    if not result and command.strip() == 'ls':
-                        success2, stdout2, stderr2 = run_command_in_container(container_name, 'ls -a', current_workdir)
-                        if success2:
-                            result = stdout2.rstrip() if stdout2 else "(directory appears empty)"
-                        else:
-                            result = f"ls failed: {stderr2.strip()}"
-                    elif not result and stderr.strip():
-                        result = f"(no output) stderr: {stderr.strip()}"
-                else:
-                    result = f"Error: {stderr.strip()}" if stderr else f"Command failed - stderr: '{stderr}'"
-
-            vm['commands'].append({
-                'command': command,
-                'result': result,
-                'time': time.time()
-            })
-
-            return result
-
-        def copy_file_to_vm(self, vm_id, local_path, container_path):
-            if vm_id not in self.vms:
-                return False
-            self._update_last_used(vm_id)
-            container_name = self.vms[vm_id]['container_name']
-            return copy_file_to_container(container_name, local_path, container_path)
-
-        def copy_file_from_vm(self, vm_id, container_path, local_path):
-            if vm_id not in self.vms:
-                return False
-            self._update_last_used(vm_id)
-            container_name = self.vms[vm_id]['container_name']
-            return copy_file_from_container(container_name, container_path, local_path)
-
-        def execute_python_streaming(self, vm_id, code, workdir=None):
-            if vm_id in self.vms:
-                self._update_last_used(vm_id)
-
-            python_vm_id = self.create_vm(
-                vcpu=0.25,
-                memory="300m",
-                image="python:3.11-slim",
-                install_python=False
-            )
-
-            if not python_vm_id:
-                yield "Error: Failed to create Python VM\n"
-                return
-
-            try:
-                python_vm = self.vms[python_vm_id]
-                container_name = python_vm['container_name']
-                current_workdir = workdir or '/'
-
-                for line in run_python_code_streaming(container_name, code, current_workdir):
-                    yield line
-
-            finally:
-                self.delete_vm(python_vm_id)
-
-        def execute_lua_streaming(self, vm_id, code, workdir=None):
-            if vm_id in self.vms:
-                self._update_last_used(vm_id)
-
-            lua_vm_id = self._ensure_lua_vm()
-            if not lua_vm_id:
-                yield "Error: Failed to ensure Lua VM is available\n"
-                return
-
-            lua_vm = self.vms[lua_vm_id]
-            container_name = lua_vm['container_name']
-            current_workdir = workdir or '/'
-
-            for line in run_lua_code_streaming(container_name, code, current_workdir):
-                yield line
-
-            self._update_last_used(lua_vm_id)
-
-        def get_vm_status(self, vm_id):
-            if vm_id not in self.vms:
-                return None
-
-            self._update_last_used(vm_id)
-            vm = self.vms[vm_id]
-            container_name = vm['container_name']
-
-            success, stdout, stderr = run_podman_cmd([
-                'ps', '--filter', f'name={container_name}', '--format', 'json'
-            ])
-
-            vm_copy = vm.copy()
-            if success and stdout:
-                try:
-                    import json as json_lib
-                    containers = json_lib.loads(stdout)
-                    if containers:
-                        vm_copy['status'] = 'running'
-                    else:
-                        vm_copy['status'] = 'stopped'
-                except:
-                    vm_copy['status'] = 'unknown'
-            else:
-                vm_copy['status'] = 'error'
-
-            return vm_copy
-
-        def get_vm_cwd(self, vm_id):
-            if vm_id not in self.vms:
-                return None
-            self._update_last_used(vm_id)
-            return self.vms[vm_id]['cwd']
-
-        def list_vms(self):
-            return list(self.vms.keys())
-
-        def delete_vm(self, vm_id):
-            if vm_id not in self.vms:
-                return False
-
-            container_name = self.vms[vm_id]['container_name']
-
-            run_podman_cmd(['stop', container_name])
-            run_podman_cmd(['rm', container_name])
-
-            del self.vms[vm_id]
-            return True
-
-    manager = VMManager()
-
-    @app.route('/')
-    def index():
-        return """
-        <html>
-        <head><title>Simple VM API</title></head>
-        <body>
-        <h1>Simple VM API</h1>
-        <p>Endpoints:</p>
-        <ul>
-        <li>POST /vm - Create VM (supports image and install_python params)</li>
-        <li>POST /vm/&lt;id&gt;/command - Run command</li>
-        <li>POST /vm/&lt;id&gt;/python - Execute Python code (streaming)</li>
-        <li>POST /vm/&lt;id&gt;/lua - Execute Lua code (streaming)</li>
-        <li>POST /vm/&lt;id&gt;/copy-to - Copy file to VM</li>
-        <li>POST /vm/&lt;id&gt;/copy-from - Copy file from VM</li>
-        <li>GET /vm/&lt;id&gt;/status - Get VM status</li>
-        <li>GET /vm/&lt;id&gt;/cwd - Get current working directory</li>
-        <li>DELETE /vm/&lt;id&gt; - Delete VM</li>
-        <li>GET /cleanup - Delete VMs unused for 10+ minutes</li>
-        <li>GET /poll - Poll for updates</li>
-        <p><strong>Server runs on port 7860</strong></p>
-        </ul>
-        </body>
-        </html>
-        """
-
-    @app.route('/vm', methods=['POST'])
-    def create_vm():
-        data = request.get_json() or {}
-        vcpu = data.get('vcpu', 1)
-        memory = data.get('memory', '512m')
-        image = data.get('image', 'debian:latest')
-        install_python = data.get('install_python', True)
-        vm_id = manager.create_vm(vcpu, memory, image, install_python)
-        return jsonify({'vm_id': vm_id, 'vcpu': vcpu, 'memory': memory, 'image': image})
-
-    @app.route('/vm/<vm_id>/command', methods=['POST'])
-    def run_command(vm_id):
-        data = request.get_json() or {}
-        command = data.get('command', '')
-
-        result = manager.run_command(vm_id, command)
-        if result is None:
-            return jsonify({'error': 'VM not found'}), 404
-
-        return jsonify({'output': result, 'command': command})
-
-    @app.route('/vm/<vm_id>/status')
-    def get_status(vm_id):
-        status = manager.get_vm_status(vm_id)
-        if not status:
-            return jsonify({'error': 'VM not found'}), 404
-        return jsonify(status)
-
-    @app.route('/vm/<vm_id>/cwd')
-    def get_cwd(vm_id):
-        cwd = manager.get_vm_cwd(vm_id)
-        if cwd is None:
-            return jsonify({'error': 'VM not found'}), 404
-        return jsonify({'cwd': cwd})
-
-    @app.route('/vm/<vm_id>/python', methods=['POST'])
-    def execute_python(vm_id):
-        if vm_id in manager.vms:
-            manager._update_last_used(vm_id)
-
-        code = None
-        if 'file' in request.files and request.files['file'].filename:
-            file = request.files['file']
-            if not file.filename.endswith('.py'):
-                return jsonify({'error': 'Only .py files are allowed'}), 400
-            file.seek(0, os.SEEK_END)
-            file_size = file.tell()
-            file.seek(0)
-            if file_size > 10 * 1024 * 1024:
-                return jsonify({'error': 'File too large (max 10MB)'}), 400
-            code = file.read().decode('utf-8')
-        elif request.is_json and request.get_json().get('code'):
-            code = request.get_json()['code']
-        else:
-            return jsonify({'error': 'No Python code provided. Use "code" field in JSON or upload a .py file'}), 400
-
-        if not code or not code.strip():
-            return jsonify({'error': 'Empty Python code'}), 400
-
-        workdir = request.args.get('workdir') or request.get_json().get('workdir') if request.is_json else None
-
-        def generate():
-            try:
-                for line in manager.execute_python_streaming(vm_id, code, workdir):
-                    yield f"data: {line}\n\n"
-            except Exception as e:
-                yield f"data: Error: {str(e)}\n\n"
-
-        return app.response_class(generate(), mimetype='text/event-stream')
-
-    @app.route('/vm/<vm_id>/lua', methods=['POST'])
-    def execute_lua(vm_id):
-        if vm_id in manager.vms:
-            manager._update_last_used(vm_id)
-
-        code = None
-        if 'file' in request.files and request.files['file'].filename:
-            file = request.files['file']
-            if not file.filename.endswith('.lua'):
-                return jsonify({'error': 'Only .lua files are allowed'}), 400
-            file.seek(0, os.SEEK_END)
-            file_size = file.tell()
-            file.seek(0)
-            if file_size > 10 * 1024 * 1024:
-                return jsonify({'error': 'File too large (max 10MB)'}), 400
-            code = file.read().decode('utf-8')
-        elif request.is_json and request.get_json().get('code'):
-            code = request.get_json()['code']
-        else:
-            return jsonify({'error': 'No Lua code provided. Use "code" field in JSON or upload a .lua file'}), 400
-
-        if not code or not code.strip():
-            return jsonify({'error': 'Empty Lua code'}), 400
-
-        workdir = request.args.get('workdir') or request.get_json().get('workdir') if request.is_json else None
-
-        def generate():
-            try:
-                for line in manager.execute_lua_streaming(vm_id, code, workdir):
-                    yield f"data: {line}\n\n"
-            except Exception as e:
-                yield f"data: Error: {str(e)}\n\n"
-
-        return app.response_class(generate(), mimetype='text/event-stream')
-
-    @app.route('/vm/<vm_id>', methods=['DELETE'])
-    def delete_vm(vm_id):
-        if manager.delete_vm(vm_id):
-            return jsonify({'message': 'VM deleted'})
-        return jsonify({'error': 'VM not found'}), 404
-
-    @app.route('/vm/<vm_id>/copy-to', methods=['POST'])
-    def copy_to_vm(vm_id):
-        data = request.get_json() or {}
-        local_path = data.get('local_path', '')
-        container_path = data.get('container_path', '')
-
-        if not local_path or not container_path:
-            return jsonify({'error': 'local_path and container_path required'}), 400
-
-        if not os.path.exists(local_path):
-            return jsonify({'error': 'Local file does not exist'}), 400
-
-        success = manager.copy_file_to_vm(vm_id, local_path, container_path)
-        if success:
-            return jsonify({'message': 'File copied successfully'})
-        return jsonify({'error': 'Failed to copy file'}), 500
-
-    @app.route('/vm/<vm_id>/copy-from', methods=['POST'])
-    def copy_from_vm(vm_id):
-        data = request.get_json() or {}
-        container_path = data.get('container_path', '')
-        local_path = data.get('local_path', '')
-
-        if not container_path or not local_path:
-            return jsonify({'error': 'container_path and local_path required'}), 400
-
-        success = manager.copy_file_from_vm(vm_id, container_path, local_path)
-        if success:
-            return jsonify({'message': 'File copied successfully'})
-        return jsonify({'error': 'Failed to copy file'}), 500
-
-    @app.route('/cleanup')
-    def cleanup():
-        def cleanup_generator():
-            import time
-            import json as json_lib
-
-            if manager._cleanup_running:
-                yield f"data: {json_lib.dumps({'event': 'busy', 'message': 'Cleanup already running, please wait...'})}\n\n"
-                return
-
-            manager._cleanup_running = True
-
-            try:
-                current_time = time.time()
-                cleanup_threshold = 600  # 10 minutes for manual cleanup
-                deleted_count = 0
-                orphaned_containers_deleted = 0
-
-                yield f"data: {json_lib.dumps({'event': 'started', 'message': 'Starting manual cleanup process (10+ minute threshold)...'})}\n\n"
-
-                vms_info = []
-                vms_to_delete = []
-
-                # First, analyze managed VMs
-                yield f"data: {json_lib.dumps({'event': 'analyzing_vms', 'message': 'Analyzing managed VMs...'})}\n\n"
-
-                for vm_id, vm in manager.vms.items():
-                    last_activity = vm.get('last_used', vm.get('created', 0))
-                    age_seconds = current_time - last_activity
-                    age_minutes = age_seconds / 60
-
-                    vm_info = {
-                        'vm_id': vm_id,
-                        'age_minutes': round(age_minutes, 1),
-                        'is_lua_vm': vm_id == manager.lua_vm_id,
-                        'should_delete': age_seconds > cleanup_threshold and vm_id != manager.lua_vm_id
-                    }
-                    vms_info.append(vm_info)
-
-                    if vm_id == manager.lua_vm_id:
-                        continue
-                    if age_seconds > cleanup_threshold:
-                        vms_to_delete.append(vm_id)
-
-                yield f"data: {json_lib.dumps({'event': 'vms_analysis_complete', 'total_vms': len(manager.vms), 'idle_vms': len(vms_to_delete), 'vms_info': vms_info})}\n\n"
-
-                # Clean up managed VMs that are idle
-                if vms_to_delete:
-                    yield f"data: {json_lib.dumps({'event': 'deleting_vms', 'message': f'Deleting {len(vms_to_delete)} idle VMs...'})}\n\n"
-
-                    for vm_id in vms_to_delete:
-                        age_minutes = round((current_time - manager.vms[vm_id].get('last_used', manager.vms[vm_id]['created'])) / 60, 1)
-                        yield f"data: {json_lib.dumps({'event': 'deleting_vm', 'vm_id': vm_id, 'age_minutes': age_minutes})}\n\n"
-
-                        print(f"Manual cleanup: deleting idle VM {vm_id} (unused for {age_minutes} minutes)")
-                        manager.delete_vm(vm_id)
-                        deleted_count += 1
-
-                        yield f"data: {json_lib.dumps({'event': 'vm_deleted', 'vm_id': vm_id, 'deleted_count': deleted_count})}\n\n"
-
-                # Now clean up orphaned podman containers
-                yield f"data: {json_lib.dumps({'event': 'checking_containers', 'message': 'Checking for orphaned podman containers...'})}\n\n"
-
-                try:
-                    # Get all containers with our naming pattern
-                    ps_success, ps_stdout, ps_stderr = run_podman_cmd(['ps', '-a', '--filter', 'name=vm-', '--format', 'json'])
-                    if ps_success and ps_stdout:
-                        try:
-                            containers = json_lib.loads(ps_stdout)
-                            orphaned_containers = []
-
-                            if isinstance(containers, list):
-                                for container in containers:
-                                    container_name = container.get('Names', [''])[0] if container.get('Names') else ''
-                                    if container_name.startswith('vm-'):
-                                        vm_id = container_name[3:]  # Remove 'vm-' prefix
-                                        # Check if this VM is still managed
-                                        if vm_id not in manager.vms:
-                                            orphaned_containers.append(container_name)
-
-                            if orphaned_containers:
-                                yield f"data: {json_lib.dumps({'event': 'orphaned_found', 'count': len(orphaned_containers), 'containers': orphaned_containers})}\n\n"
-
-                                for container_name in orphaned_containers:
-                                    yield f"data: {json_lib.dumps({'event': 'deleting_container', 'container': container_name})}\n\n"
-
-                                    print(f"Manual cleanup: deleting orphaned container {container_name}")
-                                    rm_success, rm_stdout, rm_stderr = run_podman_cmd(['rm', '-f', container_name])
-                                    if rm_success:
-                                        orphaned_containers_deleted += 1
-                                        yield f"data: {json_lib.dumps({'event': 'container_deleted', 'container': container_name, 'orphaned_deleted': orphaned_containers_deleted})}\n\n"
-                                    else:
-                                        yield f"data: {json_lib.dumps({'event': 'container_delete_failed', 'container': container_name, 'error': rm_stderr})}\n\n"
-                            else:
-                                yield f"data: {json_lib.dumps({'event': 'no_orphaned', 'message': 'No orphaned containers found'})}\n\n"
-
-                        except Exception as e:
-                            yield f"data: {json_lib.dumps({'event': 'error', 'message': f'Error parsing container list: {str(e)}'})}\n\n"
-                    else:
-                        yield f"data: {json_lib.dumps({'event': 'error', 'message': f'Failed to list containers: {ps_stderr}'})}\n\n"
-                except Exception as e:
-                    yield f"data: {json_lib.dumps({'event': 'error', 'message': f'Error checking for orphaned containers: {str(e)}'})}\n\n"
-
-                # Final summary
-                summary_data = {
-                    'event': 'completed',
-                    'summary': {
-                        'deleted_vms': deleted_count,
-                        'deleted_containers': orphaned_containers_deleted,
-                        'total_cleaned': deleted_count + orphaned_containers_deleted,
-                        'remaining_vms': len(manager.vms)
-                    }
-                }
-                yield f"data: {json_lib.dumps(summary_data)}\n\n"
-
-            finally:
-                manager._cleanup_running = False
-
-        return app.response_class(cleanup_generator(), mimetype='text/event-stream')
-
-    @app.route('/poll')
-    def poll():
-        return jsonify({'vms': manager.list_vms()})
-
-def main():
-    if len(sys.argv) < 2:
-        command = "server"
-    else:
-        command = sys.argv[1]
-
-    if command == "server":
-        if not FLASK_AVAILABLE:
-            print("Flask not available")
-            return
-
-        # Check if podman is available (will auto-install on Linux if needed)
-        check_podman, podman_version, _ = run_podman_cmd(['--version'])
-        if check_podman:
-            print(f"Podman is available - {podman_version.strip()}")
-        else:
-            print("Podman not found initially, but will be auto-installed on first use if running on Linux")
-
-        print("Starting simple VM API server on http://localhost:7860")
-        print("Podman is available - ready to create containers!")
-        app.run(host='0.0.0.0', port=7860, debug=True)
-
-    elif command == "list":
-        if not FLASK_AVAILABLE:
-            print("Flask not available")
-            return
-        manager = VMManager()
-        vms = manager.list_vms()
-        print(f"VMs: {vms}")
-
-    else:
-        print("Usage: python3 lib.py [server|list]")
-
-if __name__ == "__main__":
-    main()
+import subprocess,os,tempfile
+from flask import Flask,request,Response
+from flask_cors import CORS
+app=Flask(__name__);CORS(app)
+def run_python_code(code):
+ try:
+  with tempfile.NamedTemporaryFile(mode='w',suffix='.py',delete=False)as f:f.write(code);tf=f.name
+  r=subprocess.run(['python3',tf],capture_output=True,text=True,timeout=30)
+  os.unlink(tf)
+  return r.stdout+r.stderr
+ except:return"Error"
+@app.route('/')
+def index():return"Python API"
+@app.route('/vm/default/python',methods=['POST'])
+def run_python():d=request.get_json();c=d.get('code','');return Response(run_python_code(c),mimetype='text/plain')
+if __name__=='__main__':app.run(host='0.0.0.0',port=7860)