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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.56
+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.56 → 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.56 → golem_vm_provider-0.1.58}/provider/api/routes.py

@@ -7,13 +7,18 @@ from fastapi import APIRouter, HTTPException, Request
 from dependency_injector.wiring import inject, Provide
 from fastapi import APIRouter, HTTPException, Depends
 
-from ..config import Settings
-from ..config import Settings as _Cfg
+from typing import TYPE_CHECKING, Any
 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
@@ -27,7 +32,7 @@ router = APIRouter()
 async def create_vm(
     request: CreateVMRequest,
     vm_service: VMService = Depends(Provide[Container.vm_service]),
-    settings: Settings = Depends(Provide[Container.config]),
+    settings: Any = Depends(Provide[Container.config]),
     stream_map = Depends(Provide[Container.stream_map]),
 ) -> VMInfo:
     """Create a new VM."""
@@ -39,11 +44,12 @@ async def create_vm(
         # If payments are enabled, require a valid stream before starting
         # Determine if we should enforce gating
         enforce = False
-        spa = settings["STREAM_PAYMENT_ADDRESS"]
+        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]
                 except Exception:
                     default_spa = None
@@ -54,8 +60,10 @@ async def create_vm(
         if enforce:
             if request.stream_id is None:
                 raise HTTPException(status_code=400, detail="stream_id required when payments are enabled")
-            reader = StreamPaymentReader(settings["POLYGON_RPC_URL"], settings["STREAM_PAYMENT_ADDRESS"])
-            ok, reason = reader.verify_stream(int(request.stream_id), settings["PROVIDER_ID"])
+            rpc_url = settings.get("POLYGON_RPC_URL") if isinstance(settings, dict) else getattr(settings, "POLYGON_RPC_URL", None)
+            reader = StreamPaymentReader(rpc_url, spa)
+            expected_recipient = settings.get("PROVIDER_ID") if isinstance(settings, dict) else getattr(settings, "PROVIDER_ID", None)
+            ok, reason = reader.verify_stream(int(request.stream_id), expected_recipient)
             try:
                 s = reader.get_stream(int(request.stream_id))
                 now = int(reader.web3.eth.get_block("latest")["timestamp"])  # type: ignore[attr-defined]
@@ -73,7 +81,7 @@ async def create_vm(
         # Create VM config
         config = VMConfig(
             name=request.name,
-            image=request.image or settings["DEFAULT_VM_IMAGE"],
+            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
         )
@@ -143,7 +151,7 @@ async def get_vm_status(
 async def get_vm_access(
     requestor_name: str,
     vm_service: VMService = Depends(Provide[Container.vm_service]),
-    settings: Settings = Depends(Provide[Container.config]),
+    settings: Any = Depends(Provide[Container.config]),
 ) -> VMAccessInfo:
     """Get VM access information."""
     try:
@@ -156,7 +164,7 @@ async def get_vm_access(
             raise HTTPException(404, "VM mapping not found")
         
         return VMAccessInfo(
-            ssh_host=settings["PUBLIC_IP"] or "localhost",
+            ssh_host=((settings.get("PUBLIC_IP") if isinstance(settings, dict) else getattr(settings, "PUBLIC_IP", None)) or "localhost"),
             ssh_port=vm.ssh_port,
             vm_id=requestor_name,
             multipass_name=multipass_name
@@ -222,7 +230,7 @@ async def delete_vm(
         raise HTTPException(status_code=500, detail="An unexpected error occurred")
 @router.get("/provider/info", response_model=ProviderInfoResponse)
 @inject
-async def provider_info(settings: Settings = Depends(Provide[Container.config])) -> ProviderInfoResponse:
+async def provider_info(settings: Any = Depends(Provide[Container.config])) -> ProviderInfoResponse:
     return ProviderInfoResponse(
         provider_id=settings["PROVIDER_ID"],
         stream_payment_address=settings["STREAM_PAYMENT_ADDRESS"],
@@ -234,7 +242,7 @@ async def provider_info(settings: Settings = Depends(Provide[Container.config]))
 @inject
 async def get_vm_stream_status(
     requestor_name: str,
-    settings: Settings = Depends(Provide[Container.config]),
+    settings: Any = Depends(Provide[Container.config]),
     stream_map = Depends(Provide[Container.stream_map]),
 ) -> StreamStatus:
     """Return on-chain stream status for a VM (if mapped)."""
@@ -266,7 +274,7 @@ async def get_vm_stream_status(
 @router.get("/payments/streams", response_model=List[StreamStatus])
 @inject
 async def list_stream_statuses(
-    settings: Settings = Depends(Provide[Container.config]),
+    settings: Any = Depends(Provide[Container.config]),
     stream_map = Depends(Provide[Container.stream_map]),
 ) -> List[StreamStatus]:
     """List stream status for all mapped VMs."""
@@ -297,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.56 → golem_vm_provider-0.1.58}/provider/config.py

@@ -38,7 +38,8 @@ def ensure_config() -> None:
         created = True
 
     if created:
-        print("Using default settings – run with --help to customize")
+        # Inform the user, but write to stderr so JSON outputs on stdout remain clean
+        logger.info("Using default settings – run with --help to customize")
 
 
 if not os.environ.get("GOLEM_PROVIDER_SKIP_BOOTSTRAP") and not os.environ.get("PYTEST_CURRENT_TEST"):

{golem_vm_provider-0.1.56 → golem_vm_provider-0.1.58}/provider/container.py

@@ -2,7 +2,6 @@ import os
 from dependency_injector import containers, providers
 from pathlib import Path
 
-from .config import settings
 from .discovery.resource_tracker import ResourceTracker
 from .discovery.golem_base_advertiser import GolemBaseAdvertiser
 from .discovery.advertiser import DiscoveryServerAdvertiser
@@ -49,12 +48,12 @@ class Container(containers.DeclarativeContainer):
 
     vm_name_mapper = providers.Singleton(
         VMNameMapper,
-        db_path=Path(settings.VM_DATA_DIR) / "vm_names.json",
+        db_path=providers.Callable(lambda base: Path(base) / "vm_names.json", config.VM_DATA_DIR),
     )
 
     stream_map = providers.Singleton(
         StreamMap,
-        storage_path=Path(settings.VM_DATA_DIR) / "streams.json",
+        storage_path=providers.Callable(lambda base: Path(base) / "streams.json", config.VM_DATA_DIR),
     )
 
     port_manager = providers.Singleton(

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

@@ -1,32 +1,43 @@
 import asyncio
 import os
+import sys as _sys
 import socket
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from typing import Optional
 
-from .config import settings, ensure_config
 from .utils.logging import setup_logger
-from .utils.ascii_art import startup_animation
-from .discovery.resource_tracker import ResourceTracker
-from .discovery.advertiser import DiscoveryServerAdvertiser
+
+
+# If the invocation includes --json, mute logs as early as possible
+if "--json" in _sys.argv:
+    os.environ["GOLEM_SILENCE_LOGS"] = "1"
+
+# Defer heavy local imports (may import config) until after we decide on silence
 from .container import Container
 from .service import ProviderService
 
-
 logger = setup_logger(__name__)
 
 app = FastAPI(title="VM on Golem Provider")
 container = Container()
-# Load configuration using a dict to avoid version-specific adapters
-try:
-    container.config.from_dict(settings.model_dump())
-except Exception:
-    # Fallback for environments without pydantic v2 model_dump
-    container.config.from_pydantic(settings)
 app.container = container
 container.wire(modules=[".api.routes"])
 
+# Minimal safe defaults so DI providers that rely on config have paths before runtime
+try:
+    from pathlib import Path as _Path
+    container.config.from_dict({
+        "VM_DATA_DIR": str(_Path.home() / ".golem" / "provider" / "vms"),
+        "PROXY_STATE_DIR": str(_Path.home() / ".golem" / "provider" / "proxy"),
+        "PORT_RANGE_START": 50800,
+        "PORT_RANGE_END": 50900,
+        "PORT": 7466,
+        "SKIP_PORT_VERIFICATION": True,
+    })
+except Exception:
+    pass
+
 from .vm.models import VMNotFoundError
 from fastapi import Request
 from fastapi.responses import JSONResponse
@@ -57,6 +68,13 @@ app.add_middleware(
 @app.on_event("startup")
 async def startup_event():
     """Handle application startup."""
+    # Load configuration into container lazily at runtime
+    from .config import settings as _settings
+    try:
+        container.config.from_dict(_settings.model_dump())
+    except Exception:
+        # Fallback for environments without pydantic v2 model_dump
+        container.config.from_pydantic(_settings)
     provider_service = container.provider_service()
     await provider_service.setup(app)
 
@@ -119,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:
@@ -136,9 +159,8 @@ config_app = typer.Typer(help="Configure stream monitoring and withdrawals")
 cli.add_typer(config_app, name="config")
 
 @cli.callback()
-def main():
+def main(ctx: typer.Context):
     """VM on Golem Provider CLI"""
-    ensure_config()
     # No-op callback to initialize config; avoid custom --version flag to keep help stable
     return
 
@@ -154,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
@@ -173,15 +280,24 @@ def status(json_out: bool = typer.Option(False, "--json", help="Output machine-r
     from rich.panel import Panel
     from rich import box
 
-    # Temporarily quiet info logs during checks for cleaner UI
+    # For JSON, set a process-wide mute env that setup_logger() respects
+    import os as _os
+    if json_out:
+        _os.environ["GOLEM_SILENCE_LOGS"] = "1"
+
+    # Temporarily quiet logs; when --json, suppress near everything
     prev_level = _logger.level
+    import logging as _logging
+    _root_logger = _logging.getLogger()
+    _prev_root_level = _root_logger.level
     try:
         _logger.setLevel("WARNING")
+        if json_out:
+            _root_logger.setLevel(_logging.CRITICAL)
     except Exception:
         pass
 
     # Silence port_verifier warnings during status checks for clean UI
-    import logging as _logging
     try:
         _pv_logger = _logging.getLogger("provider.network.port_verifier")
         _prev_pv_level = _pv_logger.level
@@ -507,6 +623,22 @@ def status(json_out: bool = typer.Option(False, "--json", help="Output machine-r
                 _cfg_logger.setLevel(_prev_cfg_level)
             except Exception:
                 pass
+        # Restore root logger
+        try:
+            _root_logger.setLevel(_prev_root_level)
+        except Exception:
+            pass
+        # Restore root logger
+        try:
+            _root_logger.setLevel(_prev_root_level)
+        except Exception:
+            pass
+        # Unset mute env if we set it
+        if json_out:
+            try:
+                del _os.environ["GOLEM_SILENCE_LOGS"]
+            except Exception:
+                pass
         return
 
     console = Console()
@@ -675,6 +807,16 @@ def status(json_out: bool = typer.Option(False, "--json", help="Output machine-r
             _cfg_logger.setLevel(_prev_cfg_level)
         except Exception:
             pass
+    try:
+        _root_logger.setLevel(_prev_root_level)
+    except Exception:
+        pass
+    # Unset mute env if we set it
+    if json_out:
+        try:
+            del _os.environ["GOLEM_SILENCE_LOGS"]
+        except Exception:
+            pass
 
 
 @wallet_app.command("faucet-l2")
@@ -712,8 +854,13 @@ def streams_list(json_out: bool = typer.Option(False, "--json", help="Output in
     from web3 import Web3
     import json as _json
     try:
+        if json_out:
+            os.environ["GOLEM_SILENCE_LOGS"] = "1"
         if not settings.STREAM_PAYMENT_ADDRESS or settings.STREAM_PAYMENT_ADDRESS == "0x0000000000000000000000000000000000000000":
-            print("Streaming payments are disabled on this provider.")
+            if json_out:
+                print(_json.dumps({"error": "streaming_disabled"}, indent=2))
+            else:
+                print("Streaming payments are disabled on this provider.")
             raise typer.Exit(code=1)
         c = Container()
         c.config.from_pydantic(settings)
@@ -813,8 +960,17 @@ def streams_list(json_out: bool = typer.Option(False, "--json", help="Output in
         for row in table_rows:
             print(fmt_row(row))
     except Exception as e:
-        print(f"Error: {e}")
+        if json_out:
+            print(_json.dumps({"error": str(e)}, indent=2))
+        else:
+            print(f"Error: {e}")
         raise typer.Exit(code=1)
+    finally:
+        if json_out:
+            try:
+                del os.environ["GOLEM_SILENCE_LOGS"]
+            except Exception:
+                pass
 
 
 @streams_app.command("show")
@@ -828,12 +984,17 @@ def streams_show(vm_id: str = typer.Argument(..., help="VM id (requestor_name)")
     from web3 import Web3
     import json as _json
     try:
+        if json_out:
+            os.environ["GOLEM_SILENCE_LOGS"] = "1"
         c = Container()
         c.config.from_pydantic(settings)
         stream_map = c.stream_map()
         sid = asyncio.run(stream_map.get(vm_id))
         if sid is None:
-            print("No stream mapped for this VM.")
+            if json_out:
+                print(_json.dumps({"error": "no_stream_mapping", "vm_id": vm_id}, indent=2))
+            else:
+                print("No stream mapped for this VM.")
             raise typer.Exit(code=1)
         reader = StreamPaymentReader(settings.POLYGON_RPC_URL, settings.STREAM_PAYMENT_ADDRESS)
         s = reader.get_stream(int(sid))
@@ -896,8 +1057,17 @@ def streams_show(vm_id: str = typer.Argument(..., help="VM id (requestor_name)")
             print("  ".join("-" * wi for wi in w))
             print("  ".join(str(cols[i]).ljust(w[i]) for i in range(len(w))))
     except Exception as e:
-        print(f"Error: {e}")
+        if json_out:
+            print(_json.dumps({"error": str(e), "vm_id": vm_id}, indent=2))
+        else:
+            print(f"Error: {e}")
         raise typer.Exit(code=1)
+    finally:
+        if json_out:
+            try:
+                del os.environ["GOLEM_SILENCE_LOGS"]
+            except Exception:
+                pass
 
 @streams_app.command("earnings")
 def streams_earnings(json_out: bool = typer.Option(False, "--json", help="Output in JSON")):
@@ -910,6 +1080,8 @@ def streams_earnings(json_out: bool = typer.Option(False, "--json", help="Output
     from web3 import Web3
     import json as _json
     try:
+        if json_out:
+            os.environ["GOLEM_SILENCE_LOGS"] = "1"
         c = Container()
         c.config.from_pydantic(settings)
         stream_map = c.stream_map()
@@ -1001,8 +1173,20 @@ def streams_earnings(json_out: bool = typer.Option(False, "--json", help="Output
             for row in table:
                 print("  ".join(str(row[i]).ljust(w2[i]) for i in range(4)))
     except Exception as e:
-        print(f"Error: {e}")
+        if json_out:
+            try:
+                print(_json.dumps({"error": str(e)}, indent=2))
+            except Exception:
+                print("{\"error\": \"unexpected\"}")
+        else:
+            print(f"Error: {e}")
         raise typer.Exit(code=1)
+    finally:
+        if json_out:
+            try:
+                del os.environ["GOLEM_SILENCE_LOGS"]
+            except Exception:
+                pass
 
 
 @streams_app.command("withdraw")
@@ -1055,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.
 
@@ -1194,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
@@ -1250,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.56 → golem_vm_provider-0.1.58}/provider/utils/logging.py

@@ -1,6 +1,7 @@
 import logging
 import colorlog
 import sys
+import os
 from typing import Optional
 
 # Import standard logging levels
@@ -39,10 +40,23 @@ def setup_logger(name: Optional[str] = None, debug: bool = False) -> logging.Log
         Configured logger instance
     """
     logger = logging.getLogger(name or __name__)
+
+    # Global hard mute for JSON commands or other machine output scenarios
+    silence = os.getenv("GOLEM_SILENCE_LOGS", "").lower() in ("1", "true", "yes")
+
+    # If already configured, still adjust level according to silence/debug
     if logger.handlers:
-        return logger  # Already configured
+        target_level = logging.CRITICAL if silence else (logging.DEBUG if debug else logging.INFO)
+        logger.setLevel(target_level)
+        for h in logger.handlers:
+            try:
+                h.setLevel(target_level)
+            except Exception:
+                pass
+        return logger  # Already configured (levels updated)
 
-    handler = colorlog.StreamHandler(sys.stdout)
+    # Send logs to stderr so stdout can be reserved for machine output (e.g., --json)
+    handler = colorlog.StreamHandler(sys.stderr)
     formatter = colorlog.ColoredFormatter(
         "%(log_color)s[%(asctime)s] %(levelname)s: %(message)s",
         datefmt="%Y-%m-%d %H:%M:%S",
@@ -58,7 +72,8 @@ def setup_logger(name: Optional[str] = None, debug: bool = False) -> logging.Log
     )
     handler.setFormatter(formatter)
     logger.addHandler(handler)
-    logger.setLevel(logging.DEBUG if debug else logging.INFO)
+    # Apply level based on silence/debug
+    logger.setLevel(logging.CRITICAL if silence else (logging.DEBUG if debug else logging.INFO))
     
     return logger
 

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

@@ -7,11 +7,15 @@ import time
 import requests
 
 from ..vm.models import VMResources
-from ..config import settings
 from .logging import setup_logger
 
 logger = setup_logger(__name__)
 
+def _get_settings():
+    # Lazy import to avoid side effects during module import (e.g., JSON CLI quieting)
+    from ..config import settings as _s
+    return _s
+
 # Increase precision for financial calcs
 getcontext().prec = 28
 
@@ -21,6 +25,7 @@ def quantize_money(value: Decimal) -> Decimal:
 
 
 def _coingecko_simple_price(ids: str) -> Optional[Decimal]:
+    settings = _get_settings()
     base = settings.COINGECKO_API_URL.rstrip("/")
     url = f"{base}/simple/price"
     try:
@@ -44,6 +49,7 @@ def fetch_glm_usd_price() -> Optional[Decimal]:
 
     Tries multiple IDs to hedge against slug changes.
     """
+    settings = _get_settings()
     return _coingecko_simple_price(settings.COINGECKO_IDS)
 
 
@@ -70,6 +76,7 @@ def calculate_monthly_cost(resources: VMResources) -> Decimal:
 
     Uses the GLM-denominated price-per-unit values configured in settings.
     """
+    settings = _get_settings()
     core_price = Decimal(str(settings.PRICE_GLM_PER_CORE_MONTH))
     ram_price = Decimal(str(settings.PRICE_GLM_PER_GB_RAM_MONTH))
     storage_price = Decimal(str(settings.PRICE_GLM_PER_GB_STORAGE_MONTH))
@@ -98,6 +105,7 @@ def update_glm_unit_prices_from_usd(glm_usd: Decimal) -> Tuple[Decimal, Decimal,
 
     Returns a tuple of (core_glm, ram_glm, storage_glm).
     """
+    settings = _get_settings()
     core_usd = Decimal(str(settings.PRICE_USD_PER_CORE_MONTH))
     ram_usd = Decimal(str(settings.PRICE_USD_PER_GB_RAM_MONTH))
     storage_usd = Decimal(str(settings.PRICE_USD_PER_GB_STORAGE_MONTH))
@@ -107,6 +115,7 @@ def update_glm_unit_prices_from_usd(glm_usd: Decimal) -> Tuple[Decimal, Decimal,
     storage_glm = usd_to_glm(storage_usd, glm_usd)
 
     # Persist on settings instance (in-memory)
+    settings = _get_settings()
     settings.PRICE_GLM_PER_CORE_MONTH = float(core_glm)
     settings.PRICE_GLM_PER_GB_RAM_MONTH = float(ram_glm)
     settings.PRICE_GLM_PER_GB_STORAGE_MONTH = float(storage_glm)
@@ -129,6 +138,7 @@ class PricingAutoUpdater:
         self._last_price: Optional[Decimal] = None
 
     async def start(self):
+        settings = _get_settings()
         if not settings.PRICING_UPDATE_ENABLED:
             return
 
@@ -155,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")
@@ -173,6 +184,7 @@ class PricingAutoUpdater:
             self._last_price = new_price
             return True
         delta = abs((new_price - old) / old) * Decimal("100")
+        settings = _get_settings()
         if delta >= Decimal(str(settings.PRICING_UPDATE_MIN_DELTA_PERCENT)):
             self._last_price = new_price
             return True

{golem_vm_provider-0.1.56 → 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.56 → golem_vm_provider-0.1.58}/pyproject.toml

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