golem-vm-provider 0.1.55__py3-none-any.whl → 0.1.57__py3-none-any.whl

{golem_vm_provider-0.1.55.dist-info → golem_vm_provider-0.1.57.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: golem-vm-provider
-Version: 0.1.55
+Version: 0.1.57
 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
@@ -61,6 +61,69 @@ pip install golem-vm-provider
 golem-provider start --network testnet
 ```
 
+Verify your environment and connectivity anytime:
+
+```bash
+golem-provider status
+```
+This checks Multipass availability, local/external port reachability, and whether an update is available on PyPI.
+
+### Status Command (TTY and JSON)
+
+Use `golem-provider status` to quickly assess health.
+
+TTY output highlights
+
+```
+Overall         Error | Issues detected | Healthy
+
+Multipass       ✅ OK | ❌ Missing
+
+Provider Port   0.0.0.0:7466
+  Local         ✅ service is listening | ❌ port unavailable
+  External      ✅ reachable | ❌ unreachable — <reason>
+
+SSH Ports       <start>-<end> — OK | limited — N issue(s) | blocked
+  Usable free   <count>   # free AND externally reachable
+  In use        <count>
+  Issues        e.g. "100 not reachable externally" or "3 unreachable, 1 not listening"
+```
+
+Severity rules
+
+- Overall is Error when any critical prerequisite fails:
+  - Provider API port not externally reachable (or external check fails).
+  - No externally reachable SSH ports in the configured range.
+  - Multipass missing or provider local port not ready.
+- Otherwise it shows Issues detected or Healthy.
+
+Machine‑readable JSON
+
+```bash
+golem-provider status --json
+```
+
+Key fields:
+
+- `overall.status`: "healthy" | "issues" | "error"
+- `overall.issues`: list of concise issue strings
+- `ports.provider`:
+  - `port`: int, `host`: string
+  - `status`: "reachable" | "unreachable" (external check failures are treated as "unreachable")
+- `ports.ssh`:
+  - `range`: [start, end)
+  - `status`: "ok" | "limited" | "blocked"
+  - `usable_free`: integer — free AND externally reachable
+  - `in_use`: integer
+  - `issues`: `{ unreachable: int, not_listening: int }`
+  - `ports`: array of per‑port summaries:
+    - `{ port: int, status: "reachable" | "unreachable" | "unknown", listening: bool }`
+
+Notes
+
+- The concept of "free" in JSON is replaced by `usable_free` (free + externally reachable) to avoid misleading counts when ports are blocked.
+- When the external checker is unavailable, per‑port `status` is `"unknown"` and `listening` still reflects local state.
+
 3) Set pricing in USD (GLM rates auto‑compute):
 
 ```bash
@@ -592,13 +655,16 @@ The provider includes real-time port verification status:
 
 Example status output:
 
-```bash
-🌟 Port Verification Status
-==========================
-[✅] Provider Port {provider_port}: External ✓ | Internal ✓
-[✅] VM Access Ports: 3 ports available ({start_port}-{start_port+2})
-[✅] Overall Status: Provider Ready
-└─ Can handle up to {n} concurrent VMs
+```
+Overall         Healthy
+
+Provider Port   {host}:{provider_port}
+  Local         ✅ service is listening
+  External      ✅ reachable
+
+SSH Ports       {start_port}-{end_port_minus_one} — OK
+  Usable free   {usable_free}
+  In use        {in_use}
 ```
 
 ### Resource Allocation Issues

{golem_vm_provider-0.1.55.dist-info → golem_vm_provider-0.1.57.dist-info}/RECORD

@@ -1,9 +1,9 @@
 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=RaOhdUZLJVmCHFWHyhYF9kdBmsFSe5rThIYsW6meMrQ,13194
-provider/config.py,sha256=IDeAYQ4z8oaT5HcG9jFQhSZrLlLU6wMTGDTbSxK6FSc,28901
-provider/container.py,sha256=81x5LiA-qjYN1Uh_JdOxqvuIXiNDr9X3OXNN0VqYFCI,3681
+provider/api/routes.py,sha256=tH6_msflEgx4O6nMku_Lgg4OW-JonqXHv89NibDFc94,13678
+provider/config.py,sha256=nQzYBujgn-Z7Rqh6q0eOsTpk6R9-V-YF1OysmPpSH0Q,28993
+provider/container.py,sha256=xN1a9qClciGomppCBnEGuPPNzGQkYIWlw1lzexrjptM,3726
 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
@@ -13,8 +13,8 @@ provider/discovery/multi_advertiser.py,sha256=_J79wA1-XQ4GsLzt9KrKpWigGSGBqtut7D
 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=_j92g56B-d8CE09Ugv0fqWVMi5jw_iuTrysxSw7845A,32309
-provider/network/port_verifier.py,sha256=3l6WNwBHydggJRFYkAsuBp1eCxaU619kjWuM-zSVj2o,13267
+provider/main.py,sha256=2FicpbL8113Gvw3qQzhVHdpYixrNgIYbqwYI0nJaqRI,55746
+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/stream_map.py,sha256=qk6Y8hS72DplAifZ0ZMWPHBAyc_3IWIQyWUBuCU3_To,1191
@@ -24,9 +24,9 @@ provider/security/l2_faucet.py,sha256=yRV4xdPBgU8-LDTLqtuAijfgIoe2kYxvXqJLxFd-BV
 provider/service.py,sha256=hlQn0woppsYFHZDMEgq-40cOjmiPWruiWLy_dQvaCRU,6859
 provider/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 provider/utils/ascii_art.py,sha256=ykBFsztk57GIiz1NJ-EII5UvN74iECqQL4h9VmiW6Z8,3161
-provider/utils/logging.py,sha256=VV3oTYSRT8hUejtXLuua1M6kCHmIJgPspIkzsUVhYW0,1920
+provider/utils/logging.py,sha256=1Br806ohJyYpDIw1i8NsNpg8Xc-8-rUYwKBU4LFomLk,2623
 provider/utils/port_display.py,sha256=u1HWQFA2kPbsM-TnsQfL6Hr4KmjIZWZfsjoxarHpbW0,11981
-provider/utils/pricing.py,sha256=uTgiBJ04LuVPKkzwMTVTb6Jb7m_Z3o5XLsoMh49ixqY,6315
+provider/utils/pricing.py,sha256=eDEjt0s7REyTR-7b_3D_a_yPCnQ4req2KvtemYrE2Kw,6673
 provider/utils/retry.py,sha256=GvBjpr0DpTOgw28M2hI0yt17dpYLRwrxUUqVxWHQPtM,3148
 provider/utils/setup.py,sha256=Z5dLuBQkb5vdoQsu1HJZwXmu9NWsiBYJ7Vq9-C-_tY8,2932
 provider/vm/__init__.py,sha256=LJL504QGbqZvBbMN3G9ixMgAwvOWAKW37zUm_EiaW9M,508
@@ -39,7 +39,7 @@ provider/vm/port_manager.py,sha256=iYSwjTjD_ziOhG8aI7juKHw1OwwRUTJQyQoRUNQvz9w,1
 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.55.dist-info/METADATA,sha256=_GZ2hyX-aeTtK--VOiSE4tZfAnQwANw21tO63EvOskY,18877
-golem_vm_provider-0.1.55.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-golem_vm_provider-0.1.55.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
-golem_vm_provider-0.1.55.dist-info/RECORD,,
+golem_vm_provider-0.1.57.dist-info/METADATA,sha256=qsWTEj2YWwwpv_NTw4f6cFqFulMm5NZvMUP2iAK8-B8,20932
+golem_vm_provider-0.1.57.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+golem_vm_provider-0.1.57.dist-info/entry_points.txt,sha256=5Jiie1dIXygmxmDW66bKKxQpmBLJ7leSKRrb8bkQALw,52
+golem_vm_provider-0.1.57.dist-info/RECORD,,

provider/api/routes.py

@@ -7,8 +7,7 @@ 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
@@ -27,7 +26,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 +38,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 +54,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 +75,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 +145,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 +158,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 +224,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 +236,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 +268,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."""

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

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(

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)
 
@@ -136,13 +154,581 @@ 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
 
 
+def _get_installed_version(pkg_name: str) -> str:
+    try:
+        return metadata.version(pkg_name)
+    except Exception:
+        return "unknown"
+
+
+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
+    try:
+        import json as _json
+        from urllib.request import urlopen
+        with urlopen(f"https://pypi.org/pypi/{pkg_name}/json", timeout=5) as resp:
+            data = _json.loads(resp.read().decode("utf-8"))
+            return data.get("info", {}).get("version")
+    except Exception:
+        return None
+
+
+@cli.command("status")
+def status(json_out: bool = typer.Option(False, "--json", help="Output machine-readable JSON")):
+    """Show provider environment status and update info (pretty or JSON)."""
+    from .utils.logging import logger as _logger
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich import box
+
+    # 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
+    try:
+        _pv_logger = _logging.getLogger("provider.network.port_verifier")
+        _prev_pv_level = _pv_logger.level
+        _pv_logger.setLevel(_logging.CRITICAL)
+    except Exception:
+        _pv_logger = None
+        _prev_pv_level = None
+    # Also quiet config auto-detection logs (e.g., multipass path) for clean JSON/TTY
+    try:
+        _cfg_logger = _logging.getLogger("provider.config")
+        _prev_cfg_level = _cfg_logger.level
+        _cfg_logger.setLevel(_logging.WARNING)
+    except Exception:
+        _cfg_logger = None
+        _prev_cfg_level = None
+
+    # Defer config-heavy imports until after log levels are adjusted
+    from .config import settings as _settings
+    from .network.port_verifier import PortVerifier
+
+    # Versions
+    pkg = "golem-vm-provider"
+    current = _get_installed_version(pkg)
+    latest = _get_latest_version_from_pypi(pkg)
+    update_available = bool(latest and current != latest)
+
+    # Environment
+    env = os.environ.get("GOLEM_PROVIDER_ENVIRONMENT", _settings.ENVIRONMENT)
+    net = getattr(_settings, "NETWORK", None)
+    dev_mode = env == "development" or bool(getattr(_settings, "DEV_MODE", False))
+
+    # Multipass
+    mp = {"ok": False, "path": None, "version": None, "error": None}
+    try:
+        mp_path = _settings.MULTIPASS_BINARY_PATH
+        mp["path"] = mp_path or None
+        if mp_path:
+            import subprocess
+            r = subprocess.run([mp_path, "version"], capture_output=True, text=True, timeout=5)
+            if r.returncode == 0:
+                mp["ok"] = True
+                mp["version"] = (r.stdout or r.stderr).strip()
+            else:
+                mp["error"] = (r.stderr or r.stdout or "failed").strip()
+        else:
+            mp["error"] = "not configured"
+    except Exception as e:
+        mp["ok"] = False
+        mp["error"] = str(e)
+
+    # Provider port (local)
+    port = int(_settings.PORT)
+    host = getattr(_settings, "HOST", "0.0.0.0")
+    local = {"ok": False, "detail": None}
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(1)
+        local_conn = s.connect_ex(("127.0.0.1", port)) == 0
+        s.close()
+        if local_conn:
+            local["ok"] = True
+            local["detail"] = "service is listening"
+        else:
+            # Check that we can bind (port free)
+            if asyncio.run(verify_provider_port(port)):
+                local["ok"] = True
+                local["detail"] = "port is free (bindable)"
+            else:
+                local["ok"] = False
+                local["detail"] = "port unavailable"
+    except Exception as e:
+        local["ok"] = False
+        local["detail"] = str(e)
+
+    # Always use shared external port-checker for public reachability
+    servers = ["http://195.201.39.101:9000"]
+
+    external = {"status": "unknown", "verified_by": None, "error": None}
+    try:
+        verifier = PortVerifier(servers, discovery_port=port)
+        results = asyncio.run(verifier.verify_external_access({port}))
+        r = results.get(port)
+        if r and r.accessible:
+            external["status"] = "reachable"
+            external["verified_by"] = r.verified_by
+        elif r:
+            external["status"] = "unreachable"
+            external["error"] = r.error
+        else:
+            external["status"] = "not_verified"
+    except Exception as e:
+        external["status"] = "check_failed"
+        external["error"] = str(e).splitlines()[0]
+
+    # Base data structure
+    data = {
+        "version": {
+            "installed": current,
+            "latest": latest,
+            "update_available": update_available,
+        },
+        "environment": {
+            "environment": env,
+            "network": net,
+            "dev_mode": dev_mode,
+        },
+        "multipass": mp,
+        "ports": {
+            "provider": {
+                "port": port,
+                "host": host,
+                "local_ok": local["ok"],
+                "local_detail": local["detail"],
+                "external": external,
+            }
+        },
+    }
+
+    # SSH port usage summary from state file + external reachability for full range
+    try:
+        from pathlib import Path as _Path
+        import json as _json
+        state_path = _Path(_settings.PROXY_STATE_DIR) / "ports.json"
+        ports_in_use = []
+        if state_path.exists():
+            with open(state_path, "r") as fh:
+                st = _json.load(fh)
+            for _req_name, pinfo in (st.get("proxies", {}) or {}).items():
+                prt = pinfo.get("port")
+                if isinstance(prt, int):
+                    ports_in_use.append(prt)
+        start = int(getattr(_settings, "PORT_RANGE_START", 50800))
+        end = int(getattr(_settings, "PORT_RANGE_END", 50900))
+        total = max(0, end - start)
+        used = sorted(set(prt for prt in ports_in_use if start <= prt < end))
+        # Check if used ports are actually listening
+        used_listening = []
+        used_not_listening = []
+        for prt in used:
+            try:
+                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                s.settimeout(0.5)
+                ok = s.connect_ex(("127.0.0.1", prt)) == 0
+                s.close()
+                (used_listening if ok else used_not_listening).append(prt)
+            except Exception:
+                used_not_listening.append(prt)
+        free_count = total - len(used)
+        # External reachability across entire range
+        external_ok: set[int] = set()
+        ext_results_map: dict[int, bool] = {}
+        external_batch_ok = False
+        external_batch_error: str | None = None
+        try:
+            verifier_all = PortVerifier(servers, discovery_port=port)
+            _ext_results = asyncio.run(verifier_all.verify_external_access(set(range(start, end))))
+            for prt, res in _ext_results.items():
+                p = int(prt)
+                ok = bool(getattr(res, "accessible", False))
+                ext_results_map[p] = ok
+                if ok:
+                    external_ok.add(p)
+            external_batch_ok = True
+        except Exception:
+            # Leave external_ok empty on failure
+            external_batch_ok = False
+            try:
+                external_batch_error = str(_)  # type: ignore[name-defined]
+            except Exception:
+                external_batch_error = None
+
+        firewall_issues = [p for p in used_listening if p not in external_ok]
+
+        # Build per-port details for JSON consumers
+        details = []
+        for p in range(start, end):
+            details.append({
+                "port": p,
+                "in_use": p in used,
+                "local_listening": p in used_listening,
+                "external_reachable": bool(ext_results_map.get(p, False)) if external_batch_ok else False,
+            })
+
+        # Compute number of free ports that are actually externally reachable (usable)
+        usable_free_count = None
+        try:
+            if external_batch_ok:
+                usable_free_count = len([
+                    p for p in range(start, end)
+                    if (p not in used) and bool(ext_results_map.get(p, False))
+                ])
+        except Exception:
+            usable_free_count = None
+
+        # Legacy detailed metrics (retained under ssh_legacy)
+        _ssh_legacy = {
+            "range": [start, end],
+            "total": total,
+            "in_use": used,
+            "listening_ok": used_listening,
+            "listening_issues": used_not_listening,
+            "free_count": free_count,
+            "external_reachable_count": len([p for p in range(start, end) if p in external_ok]),
+            "firewall_issues_count": len(firewall_issues),
+            "external_checked": external_batch_ok,
+            "external_error": external_batch_error,
+            "usable_free_count": usable_free_count,
+            "details": details,
+        }
+
+        # Concise status fields for programmatic checks (mirrors TTY)
+        _ext_reach = int(len(external_ok))
+        _issues_count = len(used_not_listening) + len(firewall_issues)
+        if (not external_batch_ok) or _ext_reach == 0:
+            ssh_status = "blocked"
+        elif _issues_count > 0:
+            ssh_status = "limited"
+        else:
+            ssh_status = "ok"
+
+        # Usable free: default to 0 when external check failed
+        if usable_free_count is None:
+            usable_free_out = 0
+        else:
+            usable_free_out = int(usable_free_count)
+
+        # Issues breakdown matching TTY wording
+        unreachable_count = total if (not external_batch_ok or _ext_reach == 0) else len(firewall_issues)
+        not_listening_count = len(used_not_listening)
+
+        # Build minimal per-port status list for JSON consumers
+        # Consistent definition:
+        # - status: reachable | unreachable | unknown (unknown only if external check failed)
+        # - listening: true | false
+        ports_detail: list[dict] = []
+        for p in range(start, end):
+            listening = p in used_listening
+            if external_batch_ok:
+                status_val = "reachable" if bool(ext_results_map.get(p, False)) else "unreachable"
+            else:
+                status_val = "unknown"
+            ports_detail.append({
+                "port": p,
+                "status": status_val,
+                "listening": bool(listening),
+            })
+
+        data["ports"]["ssh"] = {
+            "range": [start, end],
+            "status": ssh_status,
+            "usable_free": usable_free_out,
+            "in_use": len(used),
+            "issues": {
+                "unreachable": int(unreachable_count),
+                "not_listening": int(not_listening_count),
+            },
+            "ports": ports_detail,
+        }
+
+    except Exception:
+        # Non-fatal; omit ssh summary if state not available
+        pass
+
+    # Provider concise status: reachable | unreachable (treat check failures as unreachable)
+    prov_status = external.get("status")
+    provider_status = "reachable" if prov_status == "reachable" else "unreachable"
+    data["ports"]["provider"]["status"] = provider_status
+
+    # Compute overall and issues for JSON output (mirrors condensed model)
+    json_issues = []
+    json_ssh_blocked = False
+    json_critical_no_ssh = False
+    # Multipass
+    if not mp["ok"]:
+        json_issues.append("Multipass not available")
+    # Provider local port
+    if not local["ok"]:
+        json_issues.append(f"Provider port {port} not ready")
+    # SSH ports
+    if data["ports"].get("ssh"):
+        _ssh = data["ports"]["ssh"]
+        _status = str(_ssh.get("status") or "blocked").lower()
+        _issues = _ssh.get("issues") or {}
+        _not_listening = int(_issues.get("not_listening", 0) or 0)
+        _unreachable = int(_issues.get("unreachable", 0) or 0)
+        if _status == "blocked":
+            json_ssh_blocked = True
+            json_critical_no_ssh = True
+            json_issues.append("No externally reachable SSH ports")
+        else:
+            if _unreachable > 0:
+                json_issues.append(f"{_unreachable} SSH port(s) unreachable externally")
+        if _not_listening > 0:
+            json_issues.append(f"{_not_listening} SSH port(s) not listening")
+    # Provider external
+    json_critical_provider_external = False
+    if external.get("status") in ("unreachable", "check_failed"):
+        json_issues.append("Provider API port not reachable externally")
+        json_critical_provider_external = True
+
+    if json_critical_no_ssh or (not local["ok"]) or (not mp["ok"]) or json_critical_provider_external:
+        overall_status = "error"
+    else:
+        overall_status = "healthy" if (not json_issues and not json_ssh_blocked) else "issues"
+
+    data["overall"] = {"status": overall_status, "issues": json_issues}
+
+    if json_out:
+        import json as _json
+        print(_json.dumps(data, indent=2))
+        # Restore logger level
+        try:
+            _logger.setLevel(prev_level)
+        except Exception:
+            pass
+        if _pv_logger and _prev_pv_level is not None:
+            try:
+                _pv_logger.setLevel(_prev_pv_level)
+            except Exception:
+                pass
+        if _cfg_logger and _prev_cfg_level is not None:
+            try:
+                _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()
+
+    # Overall status
+    issues = []
+    if not mp["ok"]:
+        issues.append("Multipass not available")
+    if not local["ok"]:
+        issues.append(f"Provider port {port} not ready")
+    ssh_blocked = False
+    critical_no_ssh = False
+    if data["ports"].get("ssh"):
+        ssh = data["ports"]["ssh"]
+        if ssh.get("listening_issues"):
+            issues.append(f"{len(ssh['listening_issues'])} SSH port(s) not listening")
+        if ssh.get("free_count", 0) == 0:
+            issues.append("No free SSH ports available")
+        if ssh.get("external_checked"):
+            if int(ssh.get("external_reachable_count", 0) or 0) == 0:
+                ssh_blocked = True
+                critical_no_ssh = True  # No externally reachable SSH ports is critical
+                issues.append("No externally reachable SSH ports")
+        else:
+            # If we couldn't check, mark as issue but not critical
+            issues.append("SSH external reachability check failed")
+    critical_provider_external = False
+    if external["status"] in ("unreachable", "check_failed"):
+        issues.append("Provider API port not reachable externally")
+        critical_provider_external = True
+
+    # Severity: Error when critical conditions are met; else Issues/Healthy
+    if critical_no_ssh or (not local["ok"]) or (not mp["ok"]) or critical_provider_external:
+        overall = "Error"
+    else:
+        overall = "Healthy" if (not issues and not ssh_blocked) else "Issues detected"
+
+    # Build a single compact table
+    tbl = Table(box=box.SIMPLE_HEAVY, show_header=False, pad_edge=False)
+    tbl.add_column("Item", style="bold")
+    tbl.add_column("Value")
+
+    # Header
+    if overall == "Healthy":
+        overall_txt = "[green]Healthy[/green]"
+    elif overall == "Error":
+        overall_txt = "[red]Error[/red]"
+    else:
+        overall_txt = f"[yellow]{overall}[/yellow]"
+    tbl.add_row("Overall", overall_txt)
+    tbl.add_row("", "")
+
+    # Versions
+    tbl.add_row("Versions", "")
+    ver_inst = data["version"]["installed"] or "unknown"
+    ver_latest = data["version"]["latest"] or "unknown"
+    upd = data["version"]["update_available"]
+    tbl.add_row("  Installed", f"[white]{ver_inst}[/white]")
+    if upd:
+        tbl.add_row("  Latest", f"[bold bright_yellow]{ver_latest}[/bold bright_yellow]  [grey62](pip install -U golem-vm-provider)[/grey62]")
+        tbl.add_row("  Update", "[bold bright_yellow]⬆️  yes[/bold bright_yellow]")
+    else:
+        tbl.add_row("  Latest", f"[cyan]{ver_latest}[/cyan]")
+        tbl.add_row("  Update", "[green]no[/green]")
+    tbl.add_row("", "")
+
+    # Environment
+    tbl.add_row("Environment", "")
+    tbl.add_row("  Environment", env + (" (dev)" if dev_mode else ""))
+    tbl.add_row("  Network", net or "-")
+    tbl.add_row("", "")
+
+    # Multipass
+    mp_ver = (mp.get("version") or mp.get("error") or "-").replace("\n", ", ")
+    tbl.add_row("Multipass", "")
+    tbl.add_row("  Status", "✅ OK" if mp["ok"] else "❌ Missing")
+    tbl.add_row("  Path", mp.get("path") or "-")
+    tbl.add_row("  Version", mp_ver)
+    tbl.add_row("", "")
+
+    # Provider port
+    tbl.add_row("Provider Port", f"{host}:{port}")
+    tbl.add_row("  Local", ("✅ " if local["ok"] else "❌ ") + (local["detail"] or ""))
+    # External reachability is foundational; treat unreachable and check failures the same
+    _ext = external.get("status") or "unknown"
+    _err = external.get("error")
+    if _ext == "reachable":
+        ext_row = "✅ reachable"
+    elif _ext in ("unreachable", "check_failed"):
+        ext_row = "❌ unreachable" + (f" — {_err}" if _err else "")
+    elif _ext == "not_verified":
+        ext_row = "⚠️ not verified"
+    else:
+        ext_row = "⚠️ " + _ext + (f" — {_err}" if _err else "")
+    tbl.add_row("  External", ext_row)
+
+    # SSH ports (condensed, actionable)
+    if data["ports"].get("ssh"):
+        ssh = data["ports"]["ssh"]
+        r0, r1 = ssh['range'][0], ssh['range'][1]-1
+        tbl.add_row("", "")
+        status_val = str(ssh.get("status") or "blocked").lower()
+        issues_obj = ssh.get("issues") or {}
+        unreachable_issues = int(issues_obj.get("unreachable", 0) or 0)
+        not_listening_issues = int(issues_obj.get("not_listening", 0) or 0)
+        in_use = int(ssh.get("in_use", 0) or 0)
+        usable_free = ssh.get("usable_free")
+
+        # Determine clear status
+        if status_val == "ok":
+            status_txt = "[green]OK[/green]"
+        elif status_val == "limited":
+            status_txt = f"[yellow]limited — {not_listening_issues + (unreachable_issues or 0)} issue(s)[/yellow]"
+        else:
+            status_txt = "[red]blocked[/red]"
+
+        tbl.add_row("SSH Ports", f"{r0}-{r1} — {status_txt}")
+
+        # Provide only the most relevant numbers
+        # Usable free = free and externally reachable; avoid misleading "Free" when blocked
+        tbl.add_row("  Usable free", str(int(usable_free or 0)))
+        tbl.add_row("  In use", str(in_use))
+        if status_val == "blocked":
+            # Show total not reachable externally
+            total_ports = (r1 - r0 + 1)
+            cnt = unreachable_issues if unreachable_issues else total_ports
+            tbl.add_row("  Issues", f"{cnt} not reachable externally")
+        elif (not_listening_issues or unreachable_issues):
+            parts = []
+            if unreachable_issues:
+                parts.append(f"{unreachable_issues} unreachable (listening but blocked)")
+            if not_listening_issues:
+                parts.append(f"{not_listening_issues} not listening")
+            tbl.add_row("  Issues", ", ".join(parts))
+
+    # Issues / Tips combined at bottom
+    # Only show Notes when there are issues
+    if issues:
+        tbl.add_row("", "")
+        tbl.add_row("Issues", "\n".join(f"• {t}" for t in issues))
+
+    console.print(Panel(tbl, title="Provider Status"))
+
+    # Tips
+    tips = []
+    if update_available:
+        tips.append("Upgrade with: pip install -U golem-vm-provider")
+    if not mp["ok"]:
+        tips.append("Install Multipass and/or set GOLEM_PROVIDER_MULTIPASS_BINARY_PATH")
+    if external["status"] != "reachable":
+        tips.append("Ensure at least one port-check server is online (see above)")
+    # Tips are included in the single panel under Notes
+
+    # Restore logger level
+    try:
+        _logger.setLevel(prev_level)
+    except Exception:
+        pass
+    if _pv_logger and _prev_pv_level is not None:
+        try:
+            _pv_logger.setLevel(_prev_pv_level)
+        except Exception:
+            pass
+    if _cfg_logger and _prev_cfg_level is not None:
+        try:
+            _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")
 def wallet_faucet_l2():
     """Request L2 faucet funds for the provider's payment address (native ETH)."""
@@ -178,8 +764,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)
@@ -279,8 +870,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")
@@ -294,12 +894,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))
@@ -362,8 +967,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")):
@@ -376,6 +990,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()
@@ -467,8 +1083,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")

provider/network/port_verifier.py

@@ -126,8 +126,8 @@ class PortVerifier:
         Returns:
             Dictionary mapping ports to their verification results
         """
-        results = {}
-        attempts = []
+        results: Dict[int, PortVerificationResult] = {}
+        attempts: List[ServerAttempt] = []
         
         # Try each server
         for server in self.port_check_servers:
@@ -146,27 +146,29 @@ class PortVerifier:
                     
                     if response.status == 200:
                         data = await response.json()
-                        if data["success"]:
-                            # Convert server results to PortVerificationResult objects
-                            for port_str, result in data["results"].items():
-                                port = int(port_str)
-                                if port not in results or not results[port].accessible:
-                                    # Only update if we haven't found a successful verification yet
-                                    results[port] = PortVerificationResult(
-                                        port=port,
-                                        accessible=result["accessible"],
-                                        error=result.get("error"),
-                                        verified_by=server if result["accessible"] else None,
-                                        attempts=[]  # Will be filled at the end
-                                    )
-                            attempts.append(ServerAttempt(server=server, success=True))
-                            logger.info(f"Port verification completed using {server}")
-                        else:
-                            attempts.append(ServerAttempt(
-                                server=server,
-                                success=False,
-                                error=f"Server {server} returned unsuccessful response"
-                            ))
+                        # Treat a 200 response as a successful attempt regardless of overall success flag.
+                        # The 'success' field in the checker indicates if any port was reachable, not server health.
+                        raw_results = data.get("results", {}) or {}
+                        for port_key, result in raw_results.items():
+                            try:
+                                port = int(port_key)
+                            except Exception:
+                                # Some implementations might already use ints
+                                port = int(result.get("port", 0)) if isinstance(result, dict) else 0
+                            if not port:
+                                continue
+                            accessible = bool(result.get("accessible"))
+                            err = result.get("error")
+                            if port not in results or (accessible and not results[port].accessible):
+                                results[port] = PortVerificationResult(
+                                    port=port,
+                                    accessible=accessible,
+                                    error=err,
+                                    verified_by=server if accessible else None,
+                                    attempts=[],
+                                )
+                        attempts.append(ServerAttempt(server=server, success=True))
+                        logger.info(f"Port verification completed using {server}")
                     else:
                         attempts.append(ServerAttempt(
                             server=server,
@@ -198,7 +200,7 @@ class PortVerifier:
                 ))
                 logger.warning(error_msg)
         
-        # If no servers were successful, fail verification
+        # If no servers responded successfully, fail verification
         if not any(attempt.success for attempt in attempts):
             error_msg = (
                 "Failed to connect to any port check servers. Please ensure:\n"
@@ -209,19 +211,15 @@ class PortVerifier:
             logger.error(error_msg)
             raise RuntimeError(error_msg)
 
-        # If no successful verifications but servers were reachable, mark ports as inaccessible
-        if not any(result.accessible for result in results.values()):
-            error_msg = "No ports were verified as accessible"
-            logger.error(error_msg)
-            results = {
-                port: PortVerificationResult(
+        # Ensure all requested ports are present in results; default to inaccessible
+        for port in ports:
+            if port not in results:
+                results[port] = PortVerificationResult(
                     port=port,
                     accessible=False,
-                    error=error_msg,
-                    attempts=[]  # Will be filled below
+                    error=None,
+                    attempts=[],
                 )
-                for port in ports
-            }
         
         # Add attempts to all results
         for result in results.values():

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
 

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
 
@@ -173,6 +183,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