lumen-app 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

lumen_app/core/server.py

@@ -240,7 +240,7 @@ def serve(config_path: str, port_override: int | None = None) -> None:
 
         # Determine port: CLI override > config file > default
         preferred_port = port_override or config.server.port or 50051
-        requested_addr = f"[::]:{preferred_port}"
+        requested_addr = f"0.0.0.0::{preferred_port}"
         try:
             bound_port = server.add_insecure_port(requested_addr)
         except RuntimeError as exc:
@@ -251,7 +251,7 @@ def serve(config_path: str, port_override: int | None = None) -> None:
 
         if bound_port == 0:
             try:
-                bound_port = server.add_insecure_port("[::]:0")
+                bound_port = server.add_insecure_port("0.0.0.0:0")
             except RuntimeError as exc:
                 logger.error(f"Unable to bind gRPC server to any port: {exc}")
                 sys.exit(1)
@@ -261,7 +261,7 @@ def serve(config_path: str, port_override: int | None = None) -> None:
             sys.exit(1)
 
         port = bound_port
-        listen_addr = f"[::]:{port}"
+        listen_addr = f"0.0.0.0:{port}"
         server.start()
 
         # Log server startup info

lumen_app/utils/installation/micromamba_installer.py

@@ -276,7 +276,7 @@ class MicromambaInstaller:
             return install_dir / "bin" / "micromamba"
 
     def _install_windows(self, install_dir: Path, dry_run: bool) -> tuple[bool, str]:
-        """Install micromamba on Windows.
+        """Install micromamba on Windows using direct binary download.
 
         Args:
             install_dir: Installation directory
@@ -287,30 +287,75 @@ class MicromambaInstaller:
         """
         logger.debug("[MicromambaInstaller] Installing on Windows")
 
-        install_script = install_dir / "install.ps1"
-        cmd = [
-            "powershell",
-            "-Command",
-            f"Invoke-WebRequest -Uri https://micro.mamba.pm/install.ps1 -OutFile {install_script}; "
-            f"& {install_script} -prefix {install_dir} -batch",
-        ]
+        # Get executable path
+        exe_path = self._get_executable_path(install_dir)
+        bin_dir = exe_path.parent
+        bin_dir.mkdir(parents=True, exist_ok=True)
 
-        if dry_run:
-            logger.info(f"[MicromambaInstaller] Would run: {' '.join(cmd)}")
-            return True, f"Would run: {' '.join(cmd)}"
+        # Build download URL (Windows is always win-64)
+        base_url = "https://github.com/mamba-org/micromamba-releases/releases/latest/download/micromamba-win-64"
 
-        try:
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=400)
+        # Get URLs with mirror fallback
+        download_urls = self.mirror_selector.get_micromamba_urls(base_url, self.region)
 
-            if result.returncode == 0:
-                return True, f"Installed to {self._get_executable_path(install_dir)}"
-            else:
-                return False, f"Installation failed: {result.stderr}"
+        logger.debug(f"[MicromambaInstaller] Platform: win-64, URLs: {download_urls}")
 
-        except subprocess.TimeoutExpired:
-            return False, "Installation timed out"
-        except Exception as e:
-            return False, f"Installation error: {str(e)}"
+        # Try each URL
+        for download_url in download_urls:
+            logger.debug(f"[MicromambaInstaller] Trying URL: {download_url}")
+
+            # Method 1: Try using curl.exe (available on Windows 10+)
+            download_cmd = ["curl", "-fsSL", download_url, "-o", str(exe_path)]
+
+            if dry_run:
+                logger.info(
+                    f"[MicromambaInstaller] Would run: {' '.join(download_cmd)}"
+                )
+                return True, f"Would download from {download_url}"
+
+            try:
+                # Try curl first
+                logger.info("[MicromambaInstaller] Downloading micromamba with curl...")
+                download_result = subprocess.run(
+                    download_cmd, capture_output=True, text=True, timeout=120
+                )
+
+                if download_result.returncode != 0:
+                    # Fallback to PowerShell
+                    logger.debug(
+                        "[MicromambaInstaller] curl failed, trying PowerShell..."
+                    )
+                    ps_cmd = [
+                        "powershell",
+                        "-Command",
+                        f"Invoke-WebRequest -Uri '{download_url}' -OutFile '{exe_path}' -UseBasicParsing",
+                    ]
+                    download_result = subprocess.run(
+                        ps_cmd, capture_output=True, text=True, timeout=120
+                    )
+
+                    if download_result.returncode != 0:
+                        logger.warning(
+                            f"[MicromambaInstaller] PowerShell download failed: {download_result.stderr}"
+                        )
+                        continue
+
+                # Configure conda-forge channels
+                self._configure_channels(exe_path)
+
+                logger.info(f"[MicromambaInstaller] Successfully installed: {exe_path}")
+                return True, f"Installed to {exe_path}"
+
+            except subprocess.TimeoutExpired:
+                logger.warning("[MicromambaInstaller] Download timed out")
+                continue
+            except Exception as e:
+                logger.warning(
+                    f"[MicromambaInstaller] Install error: {type(e).__name__}: {e}"
+                )
+                continue
+
+        return False, "Failed to download from all sources"
 
     def _install_unix(
         self, install_dir: Path, exe_path: Path, dry_run: bool

lumen_app/web/api/config.py

@@ -5,8 +5,9 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Literal
 
-import yaml
 from fastapi import APIRouter, HTTPException
+from lumen_resources.exceptions import ConfigError
+from lumen_resources.lumen_config_validator import load_and_validate_config
 
 from lumen_app.core.config import Config
 from lumen_app.core.installer import CoreInstaller
@@ -105,27 +106,40 @@ async def generate_config(request: ConfigRequest):
 @router.get("/current")
 async def get_current_config():
     """Get the currently loaded configuration."""
-    config, device_config = app_state.get_config()
+    lumen_config = app_state.get_lumen_config()
 
-    if not config or not device_config:
+    if not lumen_config:
         return {"loaded": False, "message": "No configuration loaded"}
 
+    # Extract first enabled service's backend settings for device info
+    device_info = None
+    for service_config in lumen_config.services.values():
+        if service_config.enabled and service_config.backend_settings:
+            backend = service_config.backend_settings
+            # Get runtime from first model
+            runtime = "onnx"
+            for model_cfg in service_config.models.values():
+                runtime = model_cfg.runtime.value
+                break
+
+            device_info = {
+                "runtime": runtime,
+                "batch_size": backend.batch_size or 1,
+                "precision": "fp32",
+                "rknn_device": None,
+                "onnx_providers": backend.onnx_providers or [],
+            }
+            break
+
     return {
         "loaded": True,
-        "cache_dir": config.cache_dir,
-        "region": config.region,
-        "port": config.port,
-        "service_name": config.service_name,
-        "device": {
-            "runtime": device_config.runtime.value,
-            "batch_size": device_config.batch_size,
-            "precision": device_config.precision,
-            "rknn_device": device_config.rknn_device,
-            "onnx_providers": [
-                p if isinstance(p, str) else p[0]
-                for p in (device_config.onnx_providers or [])
-            ],
-        },
+        "cache_dir": lumen_config.metadata.cache_dir,
+        "region": lumen_config.metadata.region.value,
+        "port": lumen_config.server.port,
+        "service_name": lumen_config.server.mdns.service_name
+        if lumen_config.server.mdns
+        else "lumen-server",
+        "device": device_info,
     }
 
 
@@ -207,23 +221,70 @@ async def validate_path(request: dict):
 
 @router.post("/load")
 async def load_config(config_path: str):
-    """Load a configuration from file."""
+    """Load and validate a configuration from file, then set it in app_state."""
     try:
-        path = Path(config_path).expanduser()
+        path = Path(config_path).expanduser().resolve()
+
         if not path.exists():
             raise HTTPException(
                 status_code=404, detail=f"Config file not found: {config_path}"
             )
 
-        with open(path) as f:
-            config_content = yaml.safe_load(f)
+        # Validate and load using lumen-resources
+        try:
+            lumen_config = load_and_validate_config(path)
+        except ConfigError as e:
+            logger.error(f"Configuration validation failed: {e}")
+            raise HTTPException(
+                status_code=400, detail=f"Invalid configuration: {str(e)}"
+            )
+
+        # Store LumenConfig directly in app_state
+        app_state.set_lumen_config(lumen_config)
 
-        # TODO: Parse and validate the config, then set app_state
+        logger.info(f"Configuration loaded successfully from {path}")
 
-        return {"loaded": True, "config_path": str(path), "config": config_content}
+        return {
+            "loaded": True,
+            "config_path": str(path),
+            "cache_dir": lumen_config.metadata.cache_dir,
+            "region": lumen_config.metadata.region.value,
+            "port": lumen_config.server.port,
+            "service_name": lumen_config.server.mdns.service_name
+            if lumen_config.server.mdns
+            else "lumen-server",
+        }
 
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Failed to load config: {e}")
+        logger.error(f"Failed to load config: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Failed to load config: {str(e)}")
+
+
+@router.get("/yaml")
+async def get_config_yaml():
+    """Get the current configuration as raw YAML string."""
+    lumen_config = app_state.get_lumen_config()
+
+    if not lumen_config:
+        raise HTTPException(status_code=404, detail="No configuration loaded")
+
+    try:
+        import yaml
+
+        # Convert Pydantic model to dict and then to YAML
+        config_dict = lumen_config.model_dump(mode="json")
+        yaml_str = yaml.dump(config_dict, default_flow_style=False, sort_keys=False)
+
+        return {
+            "loaded": True,
+            "yaml": yaml_str,
+            "cache_dir": lumen_config.metadata.cache_dir,
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to serialize config to YAML: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=500, detail=f"Failed to serialize config: {str(e)}"
+        )

lumen_app/web/api/install.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import os
 import time
 import uuid
 from pathlib import Path
@@ -20,18 +21,141 @@ from lumen_app.utils.logger import get_logger
 from lumen_app.utils.preset_registry import PresetRegistry
 from lumen_app.web.core.state import app_state
 from lumen_app.web.models.install import (
+    CheckInstallationPathResponse,
     InstallLogsResponse,
     InstallSetupRequest,
     InstallStatusResponse,
     InstallStep,
     InstallTaskListResponse,
     InstallTaskResponse,
+    ServiceStatus,
 )
 
 logger = get_logger("lumen.web.api.install")
 router = APIRouter()
 
 
+def _check_installation_components(cache_dir: Path) -> dict[str, bool]:
+    """Check which installation components exist at the given path.
+
+    Returns a dict with keys: micromamba, environment, config, drivers.
+    """
+    from lumen_app.utils.installation import MicromambaInstaller, MicromambaStatus
+
+    components = {
+        "micromamba": False,
+        "environment": False,
+        "config": False,
+        "drivers": False,
+    }
+
+    # Check micromamba
+    micromamba_installer = MicromambaInstaller(cache_dir)
+    micromamba_result = micromamba_installer.check()
+    components["micromamba"] = micromamba_result.status == MicromambaStatus.INSTALLED
+
+    # Check environment exists
+    # Micromamba installs to cache_dir/micromamba/, so envs are at cache_dir/micromamba/envs/
+    envs_dir = cache_dir / "micromamba" / "envs"
+    if envs_dir.exists():
+        # Look for any conda environment directories
+        components["environment"] = (
+            any(
+                (envs_dir / d).is_dir()
+                for d in os.listdir(envs_dir)
+                if (envs_dir / d).is_dir()
+            )
+            if os.path.exists(envs_dir)
+            else False
+        )
+
+    # Check config file
+    config_path = cache_dir / "lumen-config.yaml"
+    components["config"] = config_path.exists()
+
+    # Check drivers (placeholder - in a full implementation, this would check
+    # if required drivers are installed for the selected preset)
+    # For now, assume drivers are OK if micromamba and environment exist
+    components["drivers"] = components["micromamba"] and components["environment"]
+
+    return components
+
+
+@router.get("/check-path", response_model=CheckInstallationPathResponse)
+async def check_installation_path(path: str) -> CheckInstallationPathResponse:
+    """Check if an existing installation exists at the given path.
+
+    Returns detailed information about what components are installed,
+    whether the installation is complete, and the recommended action.
+    """
+    import os
+
+    if not path or not path.strip():
+        return CheckInstallationPathResponse(
+            has_existing_service=False,
+            ready_to_start=False,
+            recommended_action="configure_new",
+            message="路径为空",
+        )
+
+    try:
+        # Expand and resolve path
+        cache_dir = Path(path).expanduser().resolve()
+
+        # Check if path is valid
+        if not str(cache_dir).startswith(("/", "~")) and os.name != "nt":
+            # On non-Windows, paths must be absolute
+            if not cache_dir.is_absolute():
+                return CheckInstallationPathResponse(
+                    has_existing_service=False,
+                    ready_to_start=False,
+                    recommended_action="configure_new",
+                    message="请使用绝对路径",
+                )
+
+        # Check components
+        components = _check_installation_components(cache_dir)
+
+        # Determine if there's an existing service
+        has_existing_service = components["micromamba"] and components["environment"]
+
+        # Determine if it's ready to start
+        # For MVP: need micromamba + environment + config
+        ready_to_start = (
+            components["micromamba"]
+            and components["environment"]
+            and components["config"]
+        )
+
+        # Determine recommended action
+        if ready_to_start:
+            recommended_action = "start_existing"
+            message = "检测到完整现有安装，可以直接启动服务"
+        elif has_existing_service:
+            recommended_action = "configure_new"
+            message = "检测到部分安装，建议重新配置"
+        else:
+            recommended_action = "configure_new"
+            message = "未检测到现有安装，将进行全新配置"
+
+        return CheckInstallationPathResponse(
+            has_existing_service=has_existing_service,
+            service_status=ServiceStatus(**components),
+            ready_to_start=ready_to_start,
+            recommended_action=recommended_action,
+            message=message,
+        )
+
+    except Exception as e:
+        logger.error(f"Error checking installation path: {e}", exc_info=True)
+        return CheckInstallationPathResponse(
+            has_existing_service=False,
+            ready_to_start=False,
+            recommended_action="configure_new",
+            message=f"检查路径时出错: {str(e)}",
+        )
+
+
 @router.get("/status", response_model=InstallStatusResponse)
 async def get_install_status():
     """Get current installation status of the system."""

lumen_app/web/api/tests/__init__.py

@@ -0,0 +1 @@
+# Tests for web API endpoints

lumen_app/web/api/tests/test_install.py

@@ -0,0 +1,148 @@
+"""Tests for install API endpoints."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from fastapi.testclient import TestClient
+
+from lumen_app.web.api.install import _check_installation_components
+
+
+class TestCheckInstallationComponents:
+    """Tests for _check_installation_components function."""
+
+    def test_empty_directory_returns_no_components(self, tmp_path):
+        """Test that an empty directory returns all components as False."""
+        components = _check_installation_components(tmp_path)
+
+        assert components["micromamba"] is False
+        assert components["environment"] is False
+        assert components["config"] is False
+        assert components["drivers"] is False
+
+    def test_micromamba_detected(self, tmp_path):
+        """Test that micromamba is detected when present."""
+        # Create a mock micromamba executable
+        micromamba_dir = tmp_path / "micromamba" / "bin"
+        micromamba_dir.mkdir(parents=True)
+        micromamba_exe = micromamba_dir / "micromamba"
+        micromamba_exe.write_text("#!/bin/sh\necho 'micromamba'")
+        micromamba_exe.chmod(0o755)
+
+        with patch(
+            "lumen_app.utils.installation.MicromambaInstaller"
+        ) as mock_installer_class:
+            mock_installer = MagicMock()
+            mock_result = MagicMock()
+            mock_result.status = "INSTALLED"
+            mock_result.executable_path = str(micromamba_exe)
+            mock_installer.check.return_value = mock_result
+            mock_installer_class.return_value = mock_installer
+
+            components = _check_installation_components(tmp_path)
+
+            assert components["micromamba"] is True
+
+    def test_environment_detected(self, tmp_path):
+        """Test that environment is detected when present."""
+        env_dir = tmp_path / "envs" / "lumen_env"
+        env_dir.mkdir(parents=True)
+        (env_dir / "bin").mkdir()
+
+        components = _check_installation_components(tmp_path)
+
+        assert components["environment"] is True
+
+    def test_config_detected(self, tmp_path):
+        """Test that config is detected when present."""
+        config_file = tmp_path / "lumen-config.yaml"
+        config_file.write_text("model: test\n")
+
+        components = _check_installation_components(tmp_path)
+
+        assert components["config"] is True
+
+
+class TestCheckInstallationPathEndpoint:
+    """Tests for the /check-path endpoint."""
+
+    @pytest.fixture
+    def client(self):
+        """Create a test client."""
+        from lumen_app.web.main import create_app
+
+        app = create_app()
+        return TestClient(app)
+
+    def test_empty_path_returns_configure_new(self, client):
+        """Test that empty path returns configure_new action."""
+        response = client.get("/api/v1/install/check-path?path=")
+        assert response.status_code == 200
+
+        data = response.json()
+        assert data["recommended_action"] == "configure_new"
+        assert data["has_existing_service"] is False
+        assert data["ready_to_start"] is False
+
+    def test_no_path_returns_configure_new(self, client):
+        """Test that missing path query param returns configure_new."""
+        response = client.get("/api/v1/install/check-path")
+        assert response.status_code == 200
+
+        data = response.json()
+        assert data["recommended_action"] == "configure_new"
+
+    def test_complete_installation_detected(self, client, tmp_path):
+        """Test that a complete installation is detected."""
+        # Create complete installation
+        (tmp_path / "envs" / "lumen_env" / "bin").mkdir(parents=True)
+        (tmp_path / "lumen-config.yaml").write_text("model: test\n")
+
+        # Create mock micromamba
+        micromamba_exe = tmp_path / "micromamba" / "bin" / "micromamba"
+        micromamba_exe.parent.mkdir(parents=True)
+        micromamba_exe.write_text("#!/bin/sh\necho 'micromamba'")
+        micromamba_exe.chmod(0o755)
+
+        with patch("lumen_app.utils.installation.MicromambaInstaller") as mock_class:
+            mock_installer = MagicMock()
+            mock_result = MagicMock()
+            mock_result.status = "INSTALLED"
+            mock_result.executable_path = str(micromamba_exe)
+            mock_installer.check.return_value = mock_result
+            mock_class.return_value = mock_installer
+
+            response = client.get(f"/api/v1/install/check-path?path={tmp_path}")
+            assert response.status_code == 200
+
+            data = response.json()
+            assert data["recommended_action"] == "start_existing"
+            assert data["has_existing_service"] is True
+            assert data["ready_to_start"] is True
+            assert data["service_status"]["micromamba"] is True
+            assert data["service_status"]["environment"] is True
+            assert data["service_status"]["config"] is True
+
+    def test_partial_installation_detected(self, client, tmp_path):
+        """Test that a partial installation (only micromamba) is detected."""
+        # Create only micromamba executable (no env or config)
+        micromamba_exe = tmp_path / "micromamba" / "bin" / "micromamba"
+        micromamba_exe.parent.mkdir(parents=True)
+        micromamba_exe.write_text("#!/bin/sh\necho 'micromamba'")
+        micromamba_exe.chmod(0o755)
+
+        with patch("lumen_app.utils.installation.MicromambaInstaller") as mock_class:
+            mock_installer = MagicMock()
+            mock_result = MagicMock()
+            mock_result.status = "INSTALLED"
+            mock_result.executable_path = str(micromamba_exe)
+            mock_installer.check.return_value = mock_result
+            mock_class.return_value = mock_installer
+
+            response = client.get(f"/api/v1/install/check-path?path={tmp_path}")
+            assert response.status_code == 200
+
+            data = response.json()
+            assert data["recommended_action"] == "configure_new"
+            assert data["has_existing_service"] is True  # Has micromamba
+            assert data["ready_to_start"] is False  # But not complete

lumen_app/web/core/state.py

@@ -6,6 +6,8 @@ import asyncio
 from dataclasses import dataclass, field
 from typing import Any
 
+from lumen_resources.lumen_config import LumenConfig
+
 from lumen_app.core.config import Config, DeviceConfig
 from lumen_app.utils.env_checker import EnvironmentReport
 from lumen_app.utils.logger import get_logger
@@ -50,6 +52,7 @@ class AppState:
         self._initialized = False
         self.current_config: Config | None = None
         self.device_config: DeviceConfig | None = None
+        self.lumen_config: LumenConfig | None = None
         self.environment_report: EnvironmentReport | None = None
         self.server_status = ServerStatus()
         self.app_service: AppService | None = None
@@ -120,6 +123,15 @@ class AppState:
         """Get current configuration."""
         return self.current_config, self.device_config
 
+    def set_lumen_config(self, config: LumenConfig):
+        """Set LumenConfig directly."""
+        self.lumen_config = config
+        logger.info(f"LumenConfig loaded: {config.metadata.cache_dir}")
+
+    def get_lumen_config(self) -> LumenConfig | None:
+        """Get current LumenConfig."""
+        return self.lumen_config
+
     # Task management
     async def create_task(self, task_type: str) -> InstallationTask:
         """Create a new installation task."""

lumen_app/web/models/install.py

@@ -7,6 +7,27 @@ from typing import Literal
 from pydantic import BaseModel, Field
 
 
+class ServiceStatus(BaseModel):
+    """Service component status."""
+
+    micromamba: bool = False
+    environment: bool = False
+    config: bool = False
+    drivers: bool = False
+
+
+class CheckInstallationPathResponse(BaseModel):
+    """Response for checking installation path."""
+
+    has_existing_service: bool = False
+    service_status: ServiceStatus = Field(default_factory=ServiceStatus)
+    ready_to_start: bool = False
+    recommended_action: Literal["start_existing", "configure_new", "repair"] = (
+        "configure_new"
+    )
+    message: str = ""
+
+
 class InstallSetupRequest(BaseModel):
     """Request to start a complete installation setup.