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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.57
+Version: 0.1.59
 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.59}/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.59}/provider/api/models.py

@@ -116,6 +116,9 @@ class ProviderInfoResponse(BaseModel):
     provider_id: str
     stream_payment_address: str
     glm_token_address: str
+    ip_address: Optional[str] = None
+    country: Optional[str] = None
+    platform: Optional[str] = None
 
 
 class StreamOnChain(BaseModel):
@@ -144,3 +147,10 @@ class StreamStatus(BaseModel):
     computed: StreamComputed
     verified: bool
     reason: str
+
+
+class CreateVMJobResponse(BaseModel):
+    """Lightweight response for async VM creation scheduling."""
+    job_id: str = Field(..., description="Server-side job identifier for creation task")
+    vm_id: str = Field(..., description="Requestor VM identifier (name)")
+    status: str = Field("creating", description="Initial status indicator")

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

@@ -2,17 +2,28 @@ import json
 import os
 from typing import List
 from pathlib import Path
-from fastapi import APIRouter, HTTPException, Request
+import asyncio
+import uuid
+from fastapi import APIRouter, HTTPException, Request, Query
+from fastapi.responses import JSONResponse
 
 from dependency_injector.wiring import inject, Provide
 from fastapi import APIRouter, HTTPException, Depends
 
 from typing import TYPE_CHECKING, Any
 from ..container import Container
+from ..jobs.store import JobStore
 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,
+    CreateVMJobResponse,
+)
 from ..payments.blockchain_service import StreamPaymentReader
 from ..vm.service import VMService
 from ..vm.multipass_adapter import MultipassError
@@ -20,28 +31,30 @@ from ..vm.multipass_adapter import MultipassError
 logger = setup_logger(__name__)
 router = APIRouter()
 
+# Job status persisted in SQLite via JobStore (see Container.job_store)
 
-@router.post("/vms", response_model=VMInfo)
+
+@router.post("/vms")
 @inject
 async def create_vm(
     request: CreateVMRequest,
     vm_service: VMService = Depends(Provide[Container.vm_service]),
     settings: Any = Depends(Provide[Container.config]),
     stream_map = Depends(Provide[Container.stream_map]),
-) -> VMInfo:
-    """Create a new VM."""
+    job_store: JobStore = Depends(Provide[Container.job_store]),
+    async_mode: bool = Query(default=False, alias="async"),
+) -> Any:
+    """Create a VM (sync by default; async when `?async=true`)."""
     try:
-        logger.info(f"📥 Received VM creation request for '{request.name}'")
-        
+        logger.info(f"📥 Received VM creation request for '{request.name}' (async={async_mode})")
+
         resources = request.resources or VMResources()
 
         # If payments are enabled, require a valid stream before starting
-        # Determine if we should enforce gating
         enforce = False
         spa = (settings.get("STREAM_PAYMENT_ADDRESS") if isinstance(settings, dict) else getattr(settings, "STREAM_PAYMENT_ADDRESS", None))
         if spa and spa != "0x0000000000000000000000000000000000000000":
             if os.environ.get("PYTEST_CURRENT_TEST"):
-                # In pytest, skip gating only when using default deployment address
                 try:
                     from ..config import Settings as _Cfg  # type: ignore
                     default_spa, _ = _Cfg._load_l2_deployment()  # type: ignore[attr-defined]
@@ -67,39 +80,70 @@ async def create_vm(
                     f"start={s['startTime']} stop={s['stopTime']} rate={s['ratePerSecond']} deposit={s['deposit']} withdrawn={s['withdrawn']} remaining={remaining}s"
                 )
             except Exception:
-                # Best-effort logging; creation will continue/fail based on ok
                 pass
             if not ok:
                 raise HTTPException(status_code=400, detail=f"invalid stream: {reason}")
-        
-        # Create VM config
+
         config = VMConfig(
             name=request.name,
             image=request.image or (settings.get("DEFAULT_VM_IMAGE") if isinstance(settings, dict) else getattr(settings, "DEFAULT_VM_IMAGE", "")),
             resources=resources,
-            ssh_key=request.ssh_key
+            ssh_key=request.ssh_key,
         )
-        
-        vm_info = await vm_service.create_vm(config)
-        # Persist VM->stream mapping if provided
-        if request.stream_id is not None:
+
+        if not async_mode:
+            vm_info = await vm_service.create_vm(config)
+            if request.stream_id is not None:
+                try:
+                    await stream_map.set(vm_info.id, int(request.stream_id))
+                except Exception as e:  # noqa: BLE001
+                    logger.warning(f"failed to persist stream mapping for {vm_info.id}: {e}")
+            await vm_creation_animation(request.name)
+            return vm_info
+
+        # Async path
+        job_id = str(uuid.uuid4())
+        await job_store.create_job(job_id, request.name, status="creating")
+
+        async def _run_creation():
             try:
-                await stream_map.set(vm_info.id, int(request.stream_id))
-            except Exception as e:
-                logger.warning(f"failed to persist stream mapping for {vm_info.id}: {e}")
-        await vm_creation_animation(request.name)
-        return vm_info
+                vm_info = await vm_service.create_vm(config)
+                if request.stream_id is not None:
+                    try:
+                        await stream_map.set(vm_info.id, int(request.stream_id))
+                    except Exception as e:  # noqa: BLE001
+                        logger.warning(f"failed to persist stream mapping for {vm_info.id}: {e}")
+                await vm_creation_animation(request.name)
+                await job_store.update_job(job_id, status="ready")
+            except Exception as e:  # noqa: BLE001
+                logger.error(f"Create VM job failed: {e}")
+                await job_store.update_job(job_id, status="failed", error=str(e))
+
+        asyncio.create_task(_run_creation(), name=f"create-vm:{request.name}")
+
+        env = CreateVMJobResponse(job_id=job_id, vm_id=request.name, status="creating")
+        return JSONResponse(status_code=202, content=env.model_json_schema() and env.model_dump())
+
     except MultipassError as e:
         logger.error(f"Failed to create VM: {e}")
         raise HTTPException(status_code=500, detail=str(e))
     except HTTPException:
-        # Propagate explicit HTTP errors (e.g., payment gating)
         raise
     except Exception as e:
         logger.error(f"An unexpected error occurred: {e}")
         raise HTTPException(status_code=500, detail="An unexpected error occurred")
 
 
+@router.get("/vms/jobs/{job_id}")
+@inject
+async def get_create_job(job_id: str, job_store: JobStore = Depends(Provide[Container.job_store])):
+    """Return async creation job status."""
+    job = await job_store.get_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="job not found")
+    return job
+
+
 @router.get("/vms", response_model=List[VMInfo])
 @inject
 async def list_vms(
@@ -157,9 +201,18 @@ async def get_vm_access(
         if not multipass_name:
             raise HTTPException(404, "VM mapping not found")
         
+        # If ssh_port is not yet assigned, return 202 with a simple status payload
+        if vm.ssh_port is None:
+            return JSONResponse(status_code=202, content={
+                "vm_id": requestor_name,
+                "multipass_name": multipass_name,
+                "status": "creating",
+                "ssh_port": None,
+            })
+
         return VMAccessInfo(
             ssh_host=((settings.get("PUBLIC_IP") if isinstance(settings, dict) else getattr(settings, "PUBLIC_IP", None)) or "localhost"),
-            ssh_port=vm.ssh_port,
+            ssh_port=int(vm.ssh_port),
             vm_id=requestor_name,
             multipass_name=multipass_name
         )
@@ -225,10 +278,33 @@ async def delete_vm(
 @router.get("/provider/info", response_model=ProviderInfoResponse)
 @inject
 async def provider_info(settings: Any = Depends(Provide[Container.config])) -> ProviderInfoResponse:
+    # Derive platform similar to advertiser
+    import platform as _plat
+    raw = _plat.machine().lower()
+    platform_str = None
+    try:
+        if 'arm' in raw:
+            platform_str = 'arm64'
+        elif 'x86_64' in raw or 'amd64' in raw or 'x64' in raw:
+            platform_str = 'x86_64'
+        else:
+            platform_str = raw
+    except Exception:
+        platform_str = None
+
+    ip_addr = None
+    try:
+        ip_addr = settings.get("PUBLIC_IP") if isinstance(settings, dict) else getattr(settings, "PUBLIC_IP", None)
+    except Exception:
+        ip_addr = None
+
     return ProviderInfoResponse(
         provider_id=settings["PROVIDER_ID"],
         stream_payment_address=settings["STREAM_PAYMENT_ADDRESS"],
         glm_token_address=settings["GLM_TOKEN_ADDRESS"],
+        ip_address=ip_addr,
+        country=(settings.get("PROVIDER_COUNTRY") if isinstance(settings, dict) else getattr(settings, "PROVIDER_COUNTRY", None)),
+        platform=platform_str,
     )
 
 
@@ -299,3 +375,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.59}/provider/config.py

@@ -186,6 +186,12 @@ class Settings(BaseSettings):
         description="Min withdrawable amount (wei) before triggering withdraw"
     )
 
+    # Shutdown behavior
+    STOP_VMS_ON_EXIT: bool = Field(
+        default=False,
+        description="When true, stop all running VMs on provider shutdown. Default keeps VMs running."
+    )
+
     # Faucet settings (L3 for Golem Base adverts)
     FAUCET_URL: str = "https://ethwarsaw.holesky.golemdb.io/faucet"
     CAPTCHA_URL: str = "https://cap.gobas.me"

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.59}/provider/container.py

@@ -14,6 +14,7 @@ from .vm.name_mapper import VMNameMapper
 from .vm.port_manager import PortManager
 from .vm.proxy_manager import PythonProxyManager
 from .payments.stream_map import StreamMap
+from .jobs.store import JobStore
 from .payments.blockchain_service import StreamPaymentReader, StreamPaymentClient, StreamPaymentConfig as _SPC
 from .payments.monitor import StreamMonitor
 
@@ -119,3 +120,9 @@ class Container(containers.DeclarativeContainer):
         advertisement_service=advertisement_service,
         port_manager=port_manager,
     )
+
+    # Async job store for VM creations
+    job_store = providers.Singleton(
+        JobStore,
+        db_path=providers.Callable(lambda base: Path(base) / "jobs.sqlite", config.VM_DATA_DIR),
+    )

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.59}/provider/discovery/advertiser.py

@@ -115,6 +115,16 @@ class DiscoveryServerAdvertiser(Advertiser):
             return
 
         try:
+            import platform as _plat
+            raw = (_plat.machine() or '').lower()
+            platform_str = None
+            if raw:
+                if 'aarch64' in raw or 'arm64' in raw or raw.startswith('arm'):
+                    platform_str = 'arm64'
+                elif 'x86_64' in raw or 'amd64' in raw or 'x64' in raw:
+                    platform_str = 'x86_64'
+                else:
+                    platform_str = raw
             async with self.session.post(
                 f"{self.discovery_url}/api/v1/advertisements",
                 headers={
@@ -125,6 +135,7 @@ class DiscoveryServerAdvertiser(Advertiser):
                 json={
                     "ip_address": ip_address,
                     "country": settings.PROVIDER_COUNTRY,
+                    "platform": platform_str,
                     "resources": resources,
                     "pricing": {
                         "usd_per_core_month": settings.PRICE_USD_PER_CORE_MONTH,

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.59}/provider/discovery/golem_base_advertiser.py

@@ -65,6 +65,16 @@ class GolemBaseAdvertiser(Advertiser):
             existing_keys = await get_provider_entity_keys(self.client, settings.PROVIDER_ID)
 
             # String annotations (metadata + prices as strings; on-chain numeric annotations must be ints)
+            import platform as _plat
+            raw = (_plat.machine() or '').lower()
+            platform_str = None
+            if raw:
+                if 'aarch64' in raw or 'arm64' in raw or raw.startswith('arm'):
+                    platform_str = 'arm64'
+                elif 'x86_64' in raw or 'amd64' in raw or 'x64' in raw:
+                    platform_str = 'x86_64'
+                else:
+                    platform_str = raw
             string_annotations = [
                 Annotation(key="golem_type", value="provider"),
                 Annotation(key="golem_network", value=settings.NETWORK),
@@ -73,6 +83,7 @@ class GolemBaseAdvertiser(Advertiser):
                 Annotation(key="golem_ip_address", value=ip_address),
                 Annotation(key="golem_country", value=settings.PROVIDER_COUNTRY),
                 Annotation(key="golem_provider_name", value=settings.PROVIDER_NAME),
+                Annotation(key="golem_platform", value=platform_str or ""),
                 Annotation(key="golem_price_currency", value="USD/GLM"),
                 # Prices must be strings to avoid RLP sedes errors (ints only allowed for numeric annotations)
                 Annotation(key="golem_price_usd_core_month", value=str(float(settings.PRICE_USD_PER_CORE_MONTH))),

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.59}/provider/discovery/service.py

@@ -20,7 +20,10 @@ class AdvertisementService:
         """Stop the advertiser."""
         if self._task:
             self._task.cancel()
-            await self._task
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
         await self.advertiser.stop()
 
     async def trigger_update(self):

golem_vm_provider-0.1.59/provider/jobs/store.py

@@ -0,0 +1,116 @@
+import asyncio
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+
+@dataclass
+class JobRecord:
+    job_id: str
+    vm_id: str
+    status: str
+    error: Optional[str]
+    created_at: str
+    updated_at: str
+
+
+class JobStore:
+    """SQLite-backed store for VM creation jobs.
+
+    Keeps minimal fields to track progress and errors across restarts.
+    """
+
+    def __init__(self, db_path: Path):
+        self._db_path = Path(db_path)
+        # Ensure parent directory exists
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_schema()
+
+    def _init_schema(self) -> None:
+        conn = sqlite3.connect(self._db_path, check_same_thread=False)
+        try:
+            with conn:
+                conn.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS jobs (
+                        job_id TEXT PRIMARY KEY,
+                        vm_id TEXT NOT NULL,
+                        status TEXT NOT NULL,
+                        error TEXT,
+                        created_at TEXT NOT NULL,
+                        updated_at TEXT NOT NULL
+                    )
+                    """
+                )
+        finally:
+            conn.close()
+
+    async def create_job(self, job_id: str, vm_id: str, status: str = "creating") -> None:
+        now = datetime.now(timezone.utc).isoformat()
+
+        def _op():
+            conn = sqlite3.connect(self._db_path, check_same_thread=False)
+            try:
+                with conn:
+                    conn.execute(
+                        "INSERT OR REPLACE INTO jobs (job_id, vm_id, status, error, created_at, updated_at) VALUES (?, ?, ?, NULL, ?, ?)",
+                        (job_id, vm_id, status, now, now),
+                    )
+            finally:
+                conn.close()
+
+        await asyncio.to_thread(_op)
+
+    async def update_job(self, job_id: str, *, status: Optional[str] = None, error: Optional[str] = None) -> None:
+        now = datetime.now(timezone.utc).isoformat()
+
+        def _op():
+            conn = sqlite3.connect(self._db_path, check_same_thread=False)
+            try:
+                with conn:
+                    if status is not None and error is not None:
+                        conn.execute(
+                            "UPDATE jobs SET status = ?, error = ?, updated_at = ? WHERE job_id = ?",
+                            (status, error, now, job_id),
+                        )
+                    elif status is not None:
+                        conn.execute(
+                            "UPDATE jobs SET status = ?, updated_at = ? WHERE job_id = ?",
+                            (status, now, job_id),
+                        )
+                    elif error is not None:
+                        conn.execute(
+                            "UPDATE jobs SET error = ?, updated_at = ? WHERE job_id = ?",
+                            (error, now, job_id),
+                        )
+            finally:
+                conn.close()
+
+        await asyncio.to_thread(_op)
+
+    async def get_job(self, job_id: str) -> Optional[Dict[str, Any]]:
+        def _op():
+            conn = sqlite3.connect(self._db_path, check_same_thread=False)
+            try:
+                cur = conn.execute(
+                    "SELECT job_id, vm_id, status, error, created_at, updated_at FROM jobs WHERE job_id = ?",
+                    (job_id,),
+                )
+                row = cur.fetchone()
+                if not row:
+                    return None
+                return {
+                    "job_id": row[0],
+                    "vm_id": row[1],
+                    "status": row[2],
+                    "error": row[3],
+                    "created_at": row[4],
+                    "updated_at": row[5],
+                }
+            finally:
+                conn.close()
+
+        return await asyncio.to_thread(_op)
+

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.59}/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,89 @@ 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: bool = typer.Option(False, "--gui/--no-gui", help="Launch Electron GUI (default: no)"),
+    daemon: bool = typer.Option(False, "--daemon", help="Start in background and write a PID file"),
+    stop_vms_on_exit: Optional[bool] = typer.Option(
+        None, "--stop-vms-on-exit/--keep-vms-on-exit",
+        help="On shutdown: stop all VMs (default: keep VMs running)"
+    ),
 ):
     """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")
+        if stop_vms_on_exit is not None:
+            args.append("--stop-vms-on-exit" if stop_vms_on_exit else "--keep-vms-on-exit")
+        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,
+            stop_vms_on_exit=stop_vms_on_exit,
+        )
+
+
+@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 +1457,78 @@ 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 _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: bool = False,
+    stop_vms_on_exit: bool | None = None,
+):
     """Helper to run the uvicorn server."""
     import sys
     from pathlib import Path
@@ -1306,6 +1546,9 @@ def run_server(dev_mode: bool | None = None, no_verify_port: bool = False, netwo
     # Apply network override early (affects settings and annotations)
     if network:
         os.environ["GOLEM_PROVIDER_NETWORK"] = network
+    # Apply shutdown behavior override early so it is reflected in settings
+    if stop_vms_on_exit is not None:
+        os.environ["GOLEM_PROVIDER_STOP_VMS_ON_EXIT"] = "1" if stop_vms_on_exit else "0"
     
     # The logic for setting the public IP in dev mode is now handled in config.py
     # The following lines are no longer needed and have been removed.
@@ -1344,9 +1587,15 @@ 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) — disabled by default
+        if bool(launch_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.59}/provider/payments/monitor.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import Optional
 
 from ..utils.logging import setup_logger
+from ..vm.models import VMNotFoundError
 
 logger = setup_logger(__name__)
 
@@ -83,6 +84,16 @@ class StreamMonitor:
                         )
                         try:
                             await self.vm_service.stop_vm(vm_id)
+                        except VMNotFoundError as e:
+                            # If the VM cannot be found, remove it from the stream map
+                            # to avoid repeated stop attempts and log spam.
+                            logger.warning(f"stop_vm failed for {vm_id}: {e}")
+                            try:
+                                await self.stream_map.remove(vm_id)
+                            except Exception as rem_err:
+                                logger.debug(
+                                    f"failed to remove vm {vm_id} from stream map after not-found: {rem_err}"
+                                )
                         except Exception as e:
                             logger.warning(f"stop_vm failed for {vm_id}: {e}")
                         continue

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.59}/provider/service.py

@@ -17,6 +17,7 @@ class ProviderService:
         self.advertisement_service = advertisement_service
         self.port_manager = port_manager
         self._pricing_updater: PricingAutoUpdater | None = None
+        self._pricing_task: asyncio.Task | None = None
         self._stream_monitor = None
 
     async def setup(self, app: FastAPI):
@@ -104,7 +105,8 @@ class ProviderService:
             async def _on_price_updated(platform: str, glm_usd):
                 await self.advertisement_service.trigger_update()
             self._pricing_updater = PricingAutoUpdater(on_updated_callback=_on_price_updated)
-            asyncio.create_task(self._pricing_updater.start())
+            # Keep a handle to the background task so we can cancel it promptly on shutdown
+            self._pricing_task = asyncio.create_task(self._pricing_updater.start(), name="pricing-updater")
 
             # Start stream monitor if enabled
             from .container import Container
@@ -130,10 +132,49 @@ class ProviderService:
     async def cleanup(self):
         """Cleanup provider components."""
         logger.process("🔄 Cleaning up provider...")
-        await self.advertisement_service.stop()
-        await self.vm_service.provider.cleanup()
+        from .config import settings
+
+        # Stop advertising loop
+        try:
+            await self.advertisement_service.stop()
+        except Exception:
+            pass
+
+        # Optionally stop all running VMs based on configuration (default: keep running)
+        try:
+            if bool(getattr(settings, "STOP_VMS_ON_EXIT", False)):
+                try:
+                    vms = await self.vm_service.list_vms()
+                except Exception:
+                    vms = []
+                for vm in vms:
+                    try:
+                        await self.vm_service.stop_vm(vm.id)
+                    except Exception as e:
+                        logger.warning(f"Failed to stop VM {getattr(vm, 'id', '?')}: {e}")
+        except Exception:
+            pass
+
+        # Provider cleanup hook
+        try:
+            await self.vm_service.provider.cleanup()
+        except Exception:
+            pass
+
+        # Stop pricing updater promptly (cancel background task and set stop flag)
         if self._pricing_updater:
-            self._pricing_updater.stop()
+            try:
+                self._pricing_updater.stop()
+            except Exception:
+                pass
+        if self._pricing_task:
+            try:
+                self._pricing_task.cancel()
+                await self._pricing_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
         if self._stream_monitor:
             await self._stream_monitor.stop()
         logger.success("✨ Provider cleanup complete")

{golem_vm_provider-0.1.57 → golem_vm_provider-0.1.59}/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.59}/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.59}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "golem-vm-provider"
-version = "0.1.57"
+version = "0.1.59"
 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"