golem-vm-provider 0.1.57__tar.gz → 0.1.58__tar.gz

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.57
+Version: 0.1.58
 Summary: VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network
 Keywords: golem,vm,provider,cloud,decentralized
 Author: Phillip Jensen
@@ -470,6 +470,19 @@ golem-provider start
 GOLEM_PROVIDER_ENVIRONMENT=development golem-provider start --network testnet
 ```
 
+Run as a background service (no terminal):
+
+```bash
+# Start in background and write a PID file
+golem-provider start --daemon [--network testnet|mainnet]
+
+# Stop the background process
+golem-provider stop
+
+# Check environment and port health (unchanged)
+golem-provider status [--json]
+```
+
 ### Mode vs. Network
 
 - Development Mode (`GOLEM_PROVIDER_ENVIRONMENT=development`)

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.58}/README.md

@@ -425,6 +425,19 @@ golem-provider start
 GOLEM_PROVIDER_ENVIRONMENT=development golem-provider start --network testnet
 ```
 
+Run as a background service (no terminal):
+
+```bash
+# Start in background and write a PID file
+golem-provider start --daemon [--network testnet|mainnet]
+
+# Stop the background process
+golem-provider stop
+
+# Check environment and port health (unchanged)
+golem-provider status [--json]
+```
+
 ### Mode vs. Network
 
 - Development Mode (`GOLEM_PROVIDER_ENVIRONMENT=development`)

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.58}/provider/api/routes.py

@@ -12,7 +12,13 @@ from ..container import Container
 from ..utils.logging import setup_logger
 from ..utils.ascii_art import vm_creation_animation, vm_status_change
 from ..vm.models import VMInfo, VMAccessInfo, VMConfig, VMResources, VMNotFoundError
-from .models import CreateVMRequest, ProviderInfoResponse, StreamStatus, StreamOnChain, StreamComputed
+from .models import (
+    CreateVMRequest,
+    ProviderInfoResponse,
+    StreamStatus,
+    StreamOnChain,
+    StreamComputed,
+)
 from ..payments.blockchain_service import StreamPaymentReader
 from ..vm.service import VMService
 from ..vm.multipass_adapter import MultipassError
@@ -299,3 +305,83 @@ async def list_stream_statuses(
             logger.warning(f"stream {stream_id} lookup failed: {e}")
             continue
     return resp
+
+
+# --- GUI support endpoints ---
+@router.get("/summary")
+@inject
+async def provider_summary(
+    vm_service: VMService = Depends(Provide[Container.vm_service]),
+    settings: Any = Depends(Provide[Container.config]),
+    container: Container = Depends(Provide[Container]),
+):
+    """Concise provider summary for GUI: status, resources, pricing, VMs."""
+    try:
+        # Resources
+        rt = container.resource_tracker()
+        total = getattr(rt, "total_resources", {})
+        available = rt.get_available_resources() if hasattr(rt, "get_available_resources") else {}
+
+        # Pricing (both USD and GLM per month per unit)
+        pricing = {
+            "usd_per_core_month": float(settings["PRICE_USD_PER_CORE_MONTH"]) if isinstance(settings, dict) else float(getattr(settings, "PRICE_USD_PER_CORE_MONTH", 0)),
+            "usd_per_gb_ram_month": float(settings["PRICE_USD_PER_GB_RAM_MONTH"]) if isinstance(settings, dict) else float(getattr(settings, "PRICE_USD_PER_GB_RAM_MONTH", 0)),
+            "usd_per_gb_storage_month": float(settings["PRICE_USD_PER_GB_STORAGE_MONTH"]) if isinstance(settings, dict) else float(getattr(settings, "PRICE_USD_PER_GB_STORAGE_MONTH", 0)),
+            "glm_per_core_month": float(settings["PRICE_GLM_PER_CORE_MONTH"]) if isinstance(settings, dict) else float(getattr(settings, "PRICE_GLM_PER_CORE_MONTH", 0)),
+            "glm_per_gb_ram_month": float(settings["PRICE_GLM_PER_GB_RAM_MONTH"]) if isinstance(settings, dict) else float(getattr(settings, "PRICE_GLM_PER_GB_RAM_MONTH", 0)),
+            "glm_per_gb_storage_month": float(settings["PRICE_GLM_PER_GB_STORAGE_MONTH"]) if isinstance(settings, dict) else float(getattr(settings, "PRICE_GLM_PER_GB_STORAGE_MONTH", 0)),
+        }
+
+        # VMs
+        vms = []
+        try:
+            items = await vm_service.list_vms()
+            for vm in items:
+                vms.append({
+                    "id": vm.id,
+                    "status": vm.status.value if hasattr(vm, "status") else str(getattr(vm, "status", "")),
+                    "ssh_port": getattr(vm, "ssh_port", None),
+                    "resources": {
+                        "cpu": getattr(getattr(vm, "resources", None), "cpu", None),
+                        "memory": getattr(getattr(vm, "resources", None), "memory", None),
+                        "storage": getattr(getattr(vm, "resources", None), "storage", None),
+                    },
+                })
+        except Exception:
+            vms = []
+
+        # Basic environment info
+        env = {
+            "environment": settings["ENVIRONMENT"] if isinstance(settings, dict) else getattr(settings, "ENVIRONMENT", None),
+            "network": settings.get("NETWORK") if isinstance(settings, dict) else getattr(settings, "NETWORK", None),
+        }
+
+        return {
+            "status": "running",
+            "resources": {"total": total, "available": available},
+            "pricing": pricing,
+            "vms": vms,
+            "env": env,
+        }
+    except Exception as e:
+        logger.error(f"summary endpoint failed: {e}")
+        raise HTTPException(status_code=500, detail="failed to collect summary")
+
+
+@router.post("/admin/shutdown")
+async def admin_shutdown():
+    """Schedule a graceful provider shutdown. Returns immediately."""
+    try:
+        import asyncio, os, signal
+        loop = asyncio.get_running_loop()
+        # Try to signal our own process for a clean exit shortly after responding
+        def _sig():
+            try:
+                os.kill(os.getpid(), signal.SIGTERM)
+            except Exception:
+                os._exit(0)  # last resort
+        loop.call_later(0.2, _sig)
+        return {"ok": True}
+    except Exception as e:
+        logger.error(f"shutdown scheduling failed: {e}")
+        raise HTTPException(status_code=500, detail="failed to schedule shutdown")

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.58}/provider/main.py

@@ -137,6 +137,11 @@ async def verify_provider_port(port: int) -> bool:
 
 
 import typer
+import platform as _platform
+import signal as _signal
+import time as _time
+import shutil as _shutil
+import psutil
 try:
     from importlib import metadata
 except ImportError:
@@ -171,6 +176,91 @@ def _get_latest_version_from_pypi(pkg_name: str) -> Optional[str]:
     # Avoid network in pytest runs
     if os.environ.get("PYTEST_CURRENT_TEST"):
         return None
+
+
+# ---------------------------
+# Daemon/PID file management
+# ---------------------------
+
+def _pid_dir() -> str:
+    from pathlib import Path
+    plat = _platform.system().lower()
+    if plat.startswith("darwin"):
+        base = Path.home() / "Library" / "Application Support" / "Golem Provider"
+    elif plat.startswith("windows"):
+        base = Path(os.environ.get("APPDATA", str(Path.home() / "AppData" / "Roaming"))) / "Golem Provider"
+    else:
+        base = Path(os.environ.get("XDG_STATE_HOME", str(Path.home() / ".local" / "state"))) / "golem-provider"
+    base.mkdir(parents=True, exist_ok=True)
+    return str(base)
+
+
+def _pid_path() -> str:
+    from pathlib import Path
+    return str(Path(_pid_dir()) / "provider.pid")
+
+
+def _write_pid(pid: int) -> None:
+    with open(_pid_path(), "w") as fh:
+        fh.write(str(pid))
+
+
+def _read_pid() -> int | None:
+    try:
+        with open(_pid_path(), "r") as fh:
+            c = fh.read().strip()
+            return int(c)
+    except Exception:
+        return None
+
+
+def _remove_pid_file() -> None:
+    try:
+        os.remove(_pid_path())
+    except Exception:
+        pass
+
+
+def _is_running(pid: int) -> bool:
+    try:
+        return psutil.pid_exists(pid) and psutil.Process(pid).is_running()
+    except Exception:
+        return False
+
+
+def _spawn_detached(argv: list[str], env: dict | None = None) -> int:
+    import subprocess
+    popen_kwargs = {
+        "stdin": subprocess.DEVNULL,
+        "stdout": subprocess.DEVNULL,
+        "stderr": subprocess.DEVNULL,
+        "env": env or os.environ.copy(),
+    }
+    if _platform.system().lower().startswith("windows"):
+        creationflags = 0
+        for flag in ("CREATE_NEW_PROCESS_GROUP", "DETACHED_PROCESS"):
+            v = getattr(subprocess, flag, 0)
+            if v:
+                creationflags |= v
+        if creationflags:
+            popen_kwargs["creationflags"] = creationflags  # type: ignore[assignment]
+    else:
+        popen_kwargs["preexec_fn"] = os.setsid  # type: ignore[assignment]
+    proc = subprocess.Popen(argv, **popen_kwargs)
+    return int(proc.pid)
+
+
+def _self_command(base_args: list[str]) -> list[str]:
+    import sys
+    # When frozen (PyInstaller), sys.executable is the CLI binary
+    if getattr(sys, "frozen", False):
+        return [sys.executable] + base_args
+    # Prefer the console_script when available
+    exe = _shutil.which("golem-provider")
+    if exe:
+        return [exe] + base_args
+    # Fallback to module execution
+    return [sys.executable, "-m", "provider.main"] + base_args
     try:
         import json as _json
         from urllib.request import urlopen
@@ -1149,10 +1239,77 @@ def streams_withdraw(
 @cli.command()
 def start(
     no_verify_port: bool = typer.Option(False, "--no-verify-port", help="Skip provider port verification."),
-    network: str = typer.Option(None, "--network", help="Target network: 'testnet' or 'mainnet' (overrides env)")
+    network: str = typer.Option(None, "--network", help="Target network: 'testnet' or 'mainnet' (overrides env)"),
+    gui: Optional[bool] = typer.Option(None, "--gui/--no-gui", help="Auto-launch Electron GUI (default: auto)"),
+    daemon: bool = typer.Option(False, "--daemon", help="Start in background and write a PID file"),
 ):
     """Start the provider server."""
-    run_server(dev_mode=False, no_verify_port=no_verify_port, network=network)
+    if daemon:
+        # If a previous daemon is active, do not start another
+        pid = _read_pid()
+        if pid and _is_running(pid):
+            print(f"Provider already running (pid={pid})")
+            raise typer.Exit(code=0)
+        # Build child command and detach
+        args = ["start"]
+        if no_verify_port:
+            args.append("--no-verify-port")
+        if network:
+            args += ["--network", network]
+        # Force no GUI for daemonized child to avoid duplicates
+        args.append("--no-gui")
+        cmd = _self_command(args)
+        # Ensure GUI not auto-launched via env, regardless of defaults
+        env = {**os.environ, "GOLEM_PROVIDER_LAUNCH_GUI": "0"}
+        child_pid = _spawn_detached(cmd, env)
+        _write_pid(child_pid)
+        print(f"Started provider in background (pid={child_pid})")
+        raise typer.Exit(code=0)
+    else:
+        run_server(dev_mode=False, no_verify_port=no_verify_port, network=network, launch_gui=gui)
+
+
+@cli.command()
+def stop(timeout: int = typer.Option(15, "--timeout", help="Seconds to wait for graceful shutdown")):
+    """Stop a background provider started with --daemon."""
+    pid = _read_pid()
+    if not pid:
+        print("No PID file found; nothing to stop")
+        raise typer.Exit(code=0)
+    if not _is_running(pid):
+        print("No running provider process; cleaning up PID file")
+        _remove_pid_file()
+        raise typer.Exit(code=0)
+    try:
+        p = psutil.Process(pid)
+        p.terminate()
+    except Exception:
+        # Fallback to signal/kill
+        try:
+            if _platform.system().lower().startswith("windows"):
+                os.system(f"taskkill /PID {pid} /T /F >NUL 2>&1")
+            else:
+                os.kill(pid, _signal.SIGTERM)
+        except Exception:
+            pass
+    # Wait for exit
+    start_ts = _time.time()
+    while _time.time() - start_ts < max(0, int(timeout)):
+        if not _is_running(pid):
+            break
+        _time.sleep(0.2)
+    if _is_running(pid):
+        print("Process did not exit in time; sending kill")
+        try:
+            psutil.Process(pid).kill()
+        except Exception:
+            try:
+                if not _platform.system().lower().startswith("windows"):
+                    os.kill(pid, _signal.SIGKILL)
+            except Exception:
+                pass
+    _remove_pid_file()
+    print("Provider stopped")
 
 # Removed separate 'dev' command; use environment GOLEM_PROVIDER_ENVIRONMENT=development instead.
 
@@ -1288,7 +1445,83 @@ def _print_pricing_examples(glm_usd):
             f"- {name} ({res.cpu}C, {res.memory}GB RAM, {res.storage}GB Disk): ~{usd_str} per month (~{glm_str})"
         )
 
-def run_server(dev_mode: bool | None = None, no_verify_port: bool = False, network: str | None = None):
+def _can_launch_gui() -> bool:
+    import shutil
+    plat = _sys.platform
+    # Basic headless checks
+    if plat.startswith("linux"):
+        if not (os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")):
+            return False
+    # Require npm (or electron) available
+    return bool(shutil.which("npm") or shutil.which("electron"))
+
+
+def _maybe_launch_gui(port: int):
+    import subprocess, shutil
+    import os as _os
+    from pathlib import Path
+    root = Path(__file__).parent.parent.parent
+    gui_dir = root / "provider-gui"
+    if not gui_dir.exists():
+        logger.info("GUI directory not found; running headless")
+        return
+    cmd = None
+    npm = shutil.which("npm")
+    electron_bin = gui_dir / "node_modules" / "electron" / "dist" / ("electron.exe" if _sys.platform.startswith("win") else "electron")
+    try:
+        # Ensure dependencies (electron) are present
+        if npm and not electron_bin.exists():
+            install_cmd = [npm, "ci", "--silent"] if (gui_dir / "package-lock.json").exists() else [npm, "install", "--silent"]
+            logger.info("Installing Provider GUI dependencies…")
+            subprocess.run(install_cmd, cwd=str(gui_dir), env=os.environ, check=True)
+    except Exception as e:
+        logger.warning(f"GUI dependencies install failed: {e}")
+
+    if npm:
+        cmd = [npm, "start", "--silent"]
+    elif shutil.which("electron"):
+        cmd = ["electron", "."]
+    else:
+        logger.info("No npm/electron found; skipping GUI")
+        return
+    env = {**os.environ, "PROVIDER_API_URL": f"http://127.0.0.1:{port}/api/v1"}
+    try:
+        # Detach GUI so it won't receive terminal signals (e.g., Ctrl+C) or
+        # be terminated when the provider process exits.
+        popen_kwargs = {
+            "cwd": str(gui_dir),
+            "env": env,
+            "stdin": subprocess.DEVNULL,
+            "stdout": subprocess.DEVNULL,
+            "stderr": subprocess.DEVNULL,
+        }
+        if _sys.platform.startswith("win"):
+            # Create a new process group and detach from console on Windows
+            creationflags = 0
+            try:
+                creationflags |= getattr(subprocess, "CREATE_NEW_PROCESS_GROUP")
+            except Exception:
+                pass
+            try:
+                creationflags |= getattr(subprocess, "DETACHED_PROCESS")
+            except Exception:
+                pass
+            if creationflags:
+                popen_kwargs["creationflags"] = creationflags  # type: ignore[assignment]
+        else:
+            # Start a new session/process group on POSIX
+            try:
+                popen_kwargs["preexec_fn"] = _os.setsid  # type: ignore[assignment]
+            except Exception:
+                pass
+
+        subprocess.Popen(cmd, **popen_kwargs)
+        logger.info("Launched Provider GUI")
+    except Exception as e:
+        logger.warning(f"Failed to launch GUI: {e}")
+
+
+def run_server(dev_mode: bool | None = None, no_verify_port: bool = False, network: str | None = None, launch_gui: Optional[bool] = None):
     """Helper to run the uvicorn server."""
     import sys
     from pathlib import Path
@@ -1344,9 +1577,24 @@ def run_server(dev_mode: bool | None = None, no_verify_port: bool = False, netwo
         log_config = uvicorn.config.LOGGING_CONFIG
         log_config["formatters"]["access"]["fmt"] = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 
+        # Optionally launch GUI (non-blocking)
+        want_gui: bool
+        if launch_gui is None:
+            env_flag = os.environ.get("GOLEM_PROVIDER_LAUNCH_GUI")
+            if env_flag is not None:
+                want_gui = env_flag.strip().lower() in ("1", "true", "yes")
+            else:
+                want_gui = _can_launch_gui()
+        else:
+            want_gui = bool(launch_gui)
+        if want_gui:
+            try:
+                _maybe_launch_gui(int(settings.PORT))
+            except Exception:
+                logger.warning("GUI launch attempt failed; continuing headless")
+
         # Run server
-        logger.process(
-            f"🚀 Starting provider server on {settings.HOST}:{settings.PORT}")
+        logger.process(f"🚀 Starting provider server on {settings.HOST}:{settings.PORT}")
         uvicorn.run(
             "provider:app",
             host=settings.HOST,

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.58}/provider/utils/pricing.py

@@ -165,7 +165,8 @@ class PricingAutoUpdater:
                         update_glm_unit_prices_from_usd(glm_usd)
                         if callable(self._on_updated):
                             # Inform callback which advertising platform is active
-                            platform = getattr(settings, "ADVERTISER_TYPE", "discovery_server")
+                            _s = _get_settings()
+                            platform = getattr(_s, "ADVERTISER_TYPE", "discovery_server")
                             await self._on_updated(platform=platform, glm_usd=glm_usd)
                 else:
                     logger.warning("Skipping pricing update; failed to fetch GLM price")

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.58}/provider/vm/multipass_adapter.py

@@ -157,13 +157,25 @@ class MultipassAdapter(VMProvider):
     async def list_vms(self) -> List[VMInfo]:
         """List all VMs."""
         all_mappings = self.name_mapper.list_mappings()
-        vms = []
-        for requestor_name in all_mappings.keys():
+        vms: List[VMInfo] = []
+        for requestor_name, multipass_name in list(all_mappings.items()):
             try:
-                vm_info = await self.get_vm_status(requestor_name)
+                # get_vm_status expects multipass_name
+                vm_info = await self.get_vm_status(multipass_name)
                 vms.append(vm_info)
             except VMNotFoundError:
-                logger.warning(f"VM {requestor_name} not found, but a mapping exists. It may have been deleted externally.")
+                logger.warning(
+                    f"VM {requestor_name} not found, but a mapping exists. It may have been deleted externally."
+                )
+                # Cleanup stale mapping and proxy allocation to avoid repeated warnings
+                try:
+                    await self.proxy_manager.remove_vm(multipass_name)
+                except Exception:
+                    pass
+                try:
+                    await self.name_mapper.remove_mapping(requestor_name)
+                except Exception:
+                    pass
         return vms
 
     async def start_vm(self, multipass_name: str) -> VMInfo:
@@ -211,8 +223,8 @@ class MultipassAdapter(VMProvider):
     async def get_all_vms_resources(self) -> Dict[str, VMResources]:
         """Get resources for all running VMs."""
         all_mappings = self.name_mapper.list_mappings()
-        vm_resources = {}
-        for requestor_name, multipass_name in all_mappings.items():
+        vm_resources: Dict[str, VMResources] = {}
+        for requestor_name, multipass_name in list(all_mappings.items()):
             try:
                 info = await self._get_vm_info(multipass_name)
                 disks_info = info.get("disks", {})
@@ -223,7 +235,18 @@ class MultipassAdapter(VMProvider):
                     storage=round(total_storage / (1024**3)) if total_storage > 0 else 10
                 )
             except (MultipassError, VMNotFoundError):
-                logger.warning(f"Could not retrieve resources for VM {requestor_name} ({multipass_name}). It may have been deleted.")
+                logger.warning(
+                    f"Could not retrieve resources for VM {requestor_name} ({multipass_name}). It may have been deleted."
+                )
+                # Cleanup stale mapping and proxy allocation
+                try:
+                    await self.proxy_manager.remove_vm(multipass_name)
+                except Exception:
+                    pass
+                try:
+                    await self.name_mapper.remove_mapping(requestor_name)
+                except Exception:
+                    pass
             except Exception as e:
                 logger.error(f"Failed to get info for VM {requestor_name}: {e}")
         return vm_resources

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.58}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.57"
+version = "0.1.58"
 description = "VM on Golem Provider Node - Run your own provider node to offer VMs on the Golem Network"
 authors = ["Phillip Jensen <phillip+vm-on-golem@golemgrid.com>"]
 readme = "README.md"