golem-vm-provider 0.1.58__py3-none-any.whl → 0.1.60__py3-none-any.whl

{golem_vm_provider-0.1.58.dist-info → golem_vm_provider-0.1.60.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.58
+Version: 0.1.60
 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

{golem_vm_provider-0.1.58.dist-info → golem_vm_provider-0.1.60.dist-info}/RECORD

@@ -1,27 +1,28 @@
 provider/__init__.py,sha256=HO1fkPpZqPO3z8O8-eVIyx8xXSMIVuTR_b1YF0RtXOg,45
 provider/api/__init__.py,sha256=ssX1ugDqEPt8Fn04IymgmG-Ev8PiXLsCSaiZVvHQnec,344
-provider/api/models.py,sha256=CmfgXqSH3m0HLqY6JvUFI-2IrdGf3EhNKtZ5kbIAX-U,4304
-provider/api/routes.py,sha256=E3AxzzgqR_UgLy_I8YvtSkhy_GQlIW5EzF5FmYjF90k,17548
-provider/config.py,sha256=nQzYBujgn-Z7Rqh6q0eOsTpk6R9-V-YF1OysmPpSH0Q,28993
-provider/container.py,sha256=xN1a9qClciGomppCBnEGuPPNzGQkYIWlw1lzexrjptM,3726
+provider/api/models.py,sha256=LcEWVUE8zvX_9ByyzbyoZGiDIJf_4MLDYqX7_nRO6B0,4754
+provider/api/routes.py,sha256=egZVUyQ8MRFB_i_wmMIyZJzakddYVy0w0K8LPtNyVYw,20617
+provider/config.py,sha256=65L47ByUXoyvhD5DSsIYbM3yjlwFB5j4L6-__kAlkW0,29186
+provider/container.py,sha256=QCYlIvR1m0ediA9PwJ_OXwZU3Ye-R7G6ZGsXFDji_jQ,3957
 provider/data/deployments/l2.json,sha256=XTNN2C5LkBfp4YbDKdUKfWMdp1fKnfv8D3TgcwVWxtQ,249
 provider/discovery/__init__.py,sha256=Y6o8RxGevBpuQS3k32y-zSVbP6HBXG3veBl9ElVPKaU,349
-provider/discovery/advertiser.py,sha256=o-LiDl1j0lXMUU0-zPe3qerjpoD2360EA60Y_V_VeBc,6571
-provider/discovery/golem_base_advertiser.py,sha256=A8bg40b2Ua7PIjx3Y8-SC0s-dUUPWxaiQCzr6AcpYaQ,7334
+provider/discovery/advertiser.py,sha256=SZ4EN7zChEL9g-Dt4vqED8dAraGS-_4Iyx4F9AiVk9o,7056
+provider/discovery/golem_base_advertiser.py,sha256=LGvPLljPxh6i-80OeZnezdphtHu3Tf6nkLE8zRYY2b0,7849
 provider/discovery/golem_base_utils.py,sha256=xk7vznhMgzrn0AuGyk6-9N9ukp9oPdBbbk1RI-sVjp0,607
 provider/discovery/multi_advertiser.py,sha256=_J79wA1-XQ4GsLzt9KrKpWigGSGBqtut7DaocIk2fyE,991
 provider/discovery/resource_monitor.py,sha256=AmiEc7yBGEGXCunQ-QKmVgosDX3gOhK1Y58LJZXrwAs,949
 provider/discovery/resource_tracker.py,sha256=MP7IXd3aIMsjB4xz5Oj9zFDTEnvrnw-Cyxpl33xcJcc,6006
-provider/discovery/service.py,sha256=vX_mVSxvn3arnb2cKDM_SeJp1ZgPdImP2aUubeXgdRg,915
-provider/main.py,sha256=Iho5lJEgGCYb1BNHqMR8IJCCRJ2qGdeUbSwyF49hmRw,64487
+provider/discovery/service.py,sha256=0H4H8HuFP52xE6lrXTOUHfvaIVjbT1uzcnlPxEswjNc,1000
+provider/jobs/store.py,sha256=gLT5tWS7RmxGFfpjriECl4Kfn7osCP2woA8plKTZM4g,3958
+provider/main.py,sha256=7SGPH4RcS1K7aPf83xHaCKR0s_J-WfTJx-O8UwJzASU,64551
 provider/network/port_verifier.py,sha256=mlSzr9Z-W5Z5mL3EYg4zemgGoi8Z5ebNoeFgLGRaoH4,13253
 provider/payments/blockchain_service.py,sha256=4GrzDKwCSUVoENqjD4RLyJ0qwBOJKMyVk5Li-XNsyTc,3567
-provider/payments/monitor.py,sha256=seo8vE622IdbcRE3x69IpvHn2mel_tlMNGt_DxOIoww,5386
+provider/payments/monitor.py,sha256=qBykIXD_Fks7_VS7Mh3Zb99HMC4x4Z_2PlYaMyfBORc,6069
 provider/payments/stream_map.py,sha256=qk6Y8hS72DplAifZ0ZMWPHBAyc_3IWIQyWUBuCU3_To,1191
 provider/security/ethereum.py,sha256=EwPZj4JR8OEpto6LhKjuuT3Z9pBX6P7-UQaqJtqFkYQ,1242
 provider/security/faucet.py,sha256=8T4lW1fVQgUk8EQILgbrr9UUosw9e7eA40tlZ2_KCPQ,4368
 provider/security/l2_faucet.py,sha256=yRV4xdPBgU8-LDTLqtuAijfgIoe2kYxvXqJLxFd-BVI,2662
-provider/service.py,sha256=hlQn0woppsYFHZDMEgq-40cOjmiPWruiWLy_dQvaCRU,6859
+provider/service.py,sha256=lX017IDJYyW-zufoKts3GQptiJCR9MziQTKkJzXCk-k,8285
 provider/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 provider/utils/ascii_art.py,sha256=ykBFsztk57GIiz1NJ-EII5UvN74iECqQL4h9VmiW6Z8,3161
 provider/utils/logging.py,sha256=1Br806ohJyYpDIw1i8NsNpg8Xc-8-rUYwKBU4LFomLk,2623
@@ -33,13 +34,13 @@ provider/vm/__init__.py,sha256=LJL504QGbqZvBbMN3G9ixMgAwvOWAKW37zUm_EiaW9M,508
 provider/vm/cloud_init.py,sha256=E5dDH7dqStRcJNDfbarBBe83-c9N63W8B5ycIrHI8eU,4627
 provider/vm/models.py,sha256=hNeXgOnXWyeSiYt07Pdks0B20cDi_VC8jV-tCxULNng,6350
 provider/vm/multipass.py,sha256=rjO3GtuS4O_wXyYXSUiDGWYtQV2LpGxm6kITrA-ghBQ,617
-provider/vm/multipass_adapter.py,sha256=HW4_7cs3O_SCi1unfIvhC44duO561bpO6yrHGkqhLQA,11578
+provider/vm/multipass_adapter.py,sha256=CQlsWyI2lANVwOin7qujxRZEyMwfQNnQSxyqJNY3q2Q,12896
 provider/vm/name_mapper.py,sha256=14nKfCjJ1WkXfC4vnCYIxNGQUwcl2vcxrJYUAz4fL40,4073
 provider/vm/port_manager.py,sha256=iYSwjTjD_ziOhG8aI7juKHw1OwwRUTJQyQoRUNQvz9w,12514
 provider/vm/provider.py,sha256=A7QN89EJjcSS40_SmKeinG1Jp_NGffJaLse-XdKciAs,1164
 provider/vm/proxy_manager.py,sha256=n4NTsyz2rtrvjtf_ceKBk-g2q_mzqPwruB1q7UlQVBc,14928
 provider/vm/service.py,sha256=Ki4SGNIZUq3XmaPMwAOoNzdZzKQsmFXid374wgjFPes,4636
-golem_vm_provider-0.1.58.dist-info/METADATA,sha256=Hb6wIjErVQNKcOJva7xXtt-wGT6CIK6t5GYzVh-TVUc,21221
-golem_vm_provider-0.1.58.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-golem_vm_provider-0.1.58.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
-golem_vm_provider-0.1.58.dist-info/RECORD,,
+golem_vm_provider-0.1.60.dist-info/METADATA,sha256=8nPSP0__wjWtbFyX9espYR6kHs1jqp6B9BndLOizr0E,21221
+golem_vm_provider-0.1.60.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.60.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
+golem_vm_provider-0.1.60.dist-info/RECORD,,

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")

provider/api/routes.py

@@ -2,13 +2,17 @@ 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
@@ -18,6 +22,7 @@ from .models import (
     StreamStatus,
     StreamOnChain,
     StreamComputed,
+    CreateVMJobResponse,
 )
 from ..payments.blockchain_service import StreamPaymentReader
 from ..vm.service import VMService
@@ -26,31 +31,41 @@ from ..vm.multipass_adapter import MultipassError
 logger = setup_logger(__name__)
 router = APIRouter()
 
+# Expose Settings class at module scope for tests to monkeypatch default deployment lookup
+try:
+    from ..config import Settings as _Cfg  # type: ignore
+except Exception:  # noqa: BLE001
+    _Cfg = None  # type: ignore
 
-@router.post("/vms", response_model=VMInfo)
+# Job status persisted in SQLite via JobStore (see Container.job_store)
+
+
+@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]
+                    if _Cfg is not None:
+                        default_spa, _ = _Cfg._load_l2_deployment()  # type: ignore[attr-defined]
+                    else:
+                        default_spa = None
                 except Exception:
                     default_spa = None
                 if not default_spa or spa.lower() != default_spa.lower():
@@ -73,39 +88,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(
@@ -163,9 +209,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
         )
@@ -231,10 +286,35 @@ 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"],
+        # Provide ETH-focused alias for clients; keep legacy field too
+        eth_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,
     )
 
 

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"

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),
+    )

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,

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))),

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):

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)
+

provider/main.py

@@ -15,6 +15,7 @@ if "--json" in _sys.argv:
 
 # Defer heavy local imports (may import config) until after we decide on silence
 from .container import Container
+from .config import settings  # used by pricing CLI and server commands
 from .service import ProviderService
 
 logger = setup_logger(__name__)
@@ -1240,8 +1241,12 @@ def streams_withdraw(
 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)"),
-    gui: Optional[bool] = typer.Option(None, "--gui/--no-gui", help="Auto-launch Electron GUI (default: auto)"),
+    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."""
     if daemon:
@@ -1258,6 +1263,8 @@ def start(
             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"}
@@ -1266,7 +1273,13 @@ def start(
         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)
+        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()
@@ -1445,17 +1458,6 @@ 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 _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
@@ -1521,7 +1523,13 @@ def _maybe_launch_gui(port: int):
         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):
+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
@@ -1539,6 +1547,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.
@@ -1577,17 +1588,8 @@ 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:
+        # Optionally launch GUI (non-blocking) — disabled by default
+        if bool(launch_gui):
             try:
                 _maybe_launch_gui(int(settings.PORT))
             except Exception:

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

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")

provider/vm/multipass_adapter.py

@@ -32,6 +32,26 @@ class MultipassAdapter(VMProvider):
         self.proxy_manager = proxy_manager
         self.name_mapper = name_mapper
 
+    @staticmethod
+    def _safe_int(value, default: int = 0) -> int:
+        """Best-effort int conversion that treats missing/blank values as default.
+
+        Multipass may return empty strings for numeric fields (e.g., when a VM is
+        stopped). This helper prevents ValueError by mapping '', None, or
+        unparsable values to a sensible default.
+        """
+        try:
+            if value is None:
+                return default
+            if isinstance(value, str):
+                v = value.strip()
+                if v == "":
+                    return default
+                return int(v)
+            return int(value)
+        except (ValueError, TypeError):
+            return default
+
     async def _run_multipass(self, args: List[str], check: bool = True) -> subprocess.CompletedProcess:
         """Run a multipass command."""
         # Commands that produce JSON or version info that we need to parse.
@@ -160,8 +180,8 @@ class MultipassAdapter(VMProvider):
         vms: List[VMInfo] = []
         for requestor_name, multipass_name in list(all_mappings.items()):
             try:
-                # get_vm_status expects multipass_name
-                vm_info = await self.get_vm_status(multipass_name)
+                # Pass requestor id; get_vm_status accepts either id
+                vm_info = await self.get_vm_status(requestor_name)
                 vms.append(vm_info)
             except VMNotFoundError:
                 logger.warning(
@@ -188,30 +208,40 @@ class MultipassAdapter(VMProvider):
         await self._run_multipass(["stop", multipass_name])
         return await self.get_vm_status(multipass_name)
 
-    async def get_vm_status(self, multipass_name: str) -> VMInfo:
-        """Get the status of a VM."""
+    async def get_vm_status(self, name_or_id: str) -> VMInfo:
+        """Get VM status by multipass name or requestor id."""
+        # Resolve identifiers flexibly
+        requestor_name = await self.name_mapper.get_requestor_name(name_or_id)
+        if requestor_name:
+            multipass_name = name_or_id
+        else:
+            multipass_name = await self.name_mapper.get_multipass_name(name_or_id)
+            if not multipass_name:
+                raise VMNotFoundError(f"VM {name_or_id} mapping not found")
+            requestor_name = name_or_id
         try:
             info = await self._get_vm_info(multipass_name)
         except MultipassError:
             raise VMNotFoundError(f"VM {multipass_name} not found in multipass")
 
-        requestor_name = await self.name_mapper.get_requestor_name(multipass_name)
-        if not requestor_name:
-            raise VMNotFoundError(f"Mapping for VM {multipass_name} not found")
-
         ipv4 = info.get("ipv4")
         ip_address = ipv4[0] if ipv4 else None
         logger.debug(f"Parsed VM info for {requestor_name}: {info}")
         
         disks_info = info.get("disks", {})
-        total_storage = sum(int(disk.get("total", 0)) for disk in disks_info.values())
+        total_storage = 0
+        for disk in disks_info.values():
+            total_storage += self._safe_int(disk.get("total"), 0)
+
+        # Memory reported by multipass is in bytes; default to 1 GiB if missing/blank
+        mem_total_bytes = self._safe_int(info.get("memory", {}).get("total"), 1024**3)
         vm_info_obj = VMInfo(
             id=requestor_name,
             name=requestor_name,
             status=VMStatus(info["state"].lower()),
             resources=VMResources(
-                cpu=int(info.get("cpu_count", "1")),
-                memory=round(info.get("memory", {}).get("total", 1024**3) / (1024**3)),
+                cpu=self._safe_int(info.get("cpu_count"), 1),
+                memory=round(mem_total_bytes / (1024**3)),
                 storage=round(total_storage / (1024**3)) if total_storage > 0 else 10
             ),
             ip_address=ip_address,
@@ -228,10 +258,13 @@ class MultipassAdapter(VMProvider):
             try:
                 info = await self._get_vm_info(multipass_name)
                 disks_info = info.get("disks", {})
-                total_storage = sum(int(disk.get("total", 0)) for disk in disks_info.values())
+                total_storage = 0
+                for disk in disks_info.values():
+                    total_storage += self._safe_int(disk.get("total"), 0)
+                mem_total_bytes = self._safe_int(info.get("memory", {}).get("total"), 1024**3)
                 vm_resources[requestor_name] = VMResources(
-                    cpu=int(info.get("cpu_count", "1")),
-                    memory=round(info.get("memory", {}).get("total", 1024**3) / (1024**3)),
+                    cpu=self._safe_int(info.get("cpu_count"), 1),
+                    memory=round(mem_total_bytes / (1024**3)),
                     storage=round(total_storage / (1024**3)) if total_storage > 0 else 10
                 )
             except (MultipassError, VMNotFoundError):