levain-runtime 0.1.4__tar.gz → 0.1.6__tar.gz

{levain_runtime-0.1.4 → levain_runtime-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: levain-runtime
-Version: 0.1.4
+Version: 0.1.6
 Summary: Self-hosted runtime for Levain agents: run an agent's nodes on your own machine or container while the platform drives the recipe
 License-Expression: Apache-2.0
 License-File: LICENSE

{levain_runtime-0.1.4 → levain_runtime-0.1.6}/levain_runtime/cli.py

@@ -12,7 +12,7 @@ import sys
 import time
 from importlib import resources
 from pathlib import Path
-from typing import Annotated
+from typing import Annotated, Any
 
 import httpx
 import typer
@@ -371,18 +371,39 @@ def up() -> None:
     _serve(config)
 
 
+def _live_health() -> dict[str, Any] | None:
+    try:
+        resp = httpx.get(
+            f"http://127.0.0.1:{RUNNER_HTTP_PORT}/v1/health", timeout=2.0
+        )
+        resp.raise_for_status()
+        body = resp.json()
+    except (httpx.HTTPError, ValueError):
+        return None
+    return body if isinstance(body, dict) else None
+
+
 @app.command()
 def status() -> None:
     """Show the configuration and the sessions on this runtime."""
     config = _load_config()
-    manager = SessionManager(config)
+    # Read-only: the startup reset belongs to the running service.
+    manager = SessionManager(config, restore=False)
+    live = _live_health()
     print(f"home: {config.root}")
     print(
         f"mode: {config.mode}" + (f" ({config.image})" if config.image else "")
     )
+    print("service: " + ("running" if live else "not running"))
     if config.credentials:
         print(f"runtime: {config.credentials.runtime_id}")
-        print(f"gateway: {chisel.gateway(config.credentials)}")
+        if live and live.get("gateway"):
+            print(f"gateway: {live['gateway']}")
+        else:
+            print(
+                f"gateway: {chisel.gateway(config.credentials)}"
+                " (from this shell)"
+            )
     else:
         print("runtime: not connected")
     if config.mode == "direct":
@@ -392,11 +413,14 @@ def status() -> None:
         f"chisel: {os.environ.get('CHISEL_BIN') or config.root / 'bin' / 'chisel'}"
     )
     sessions = manager.store.all()
-    print(
-        f"sessions: {len(sessions)} ({len(manager.active_sessions())} active)"
-    )
+    if live:
+        active = set(live.get("active_sessions") or [])
+    else:
+        active = {m.sid for m in sessions if m.state == "active"}
+    print(f"sessions: {len(sessions)} ({len(active)} active)")
     for meta in sessions:
-        print(f"  {meta.sid} {meta.state} {meta.workspace_dir}")
+        state = "active" if meta.sid in active else "paused"
+        print(f"  {meta.sid} {state} {meta.workspace_dir}")
 
 
 def _serve(config: RuntimeConfig) -> None:

{levain_runtime-0.1.4 → levain_runtime-0.1.6}/levain_runtime/server.py

@@ -13,6 +13,7 @@ from starlette.requests import Request
 from starlette.responses import JSONResponse, Response, StreamingResponse
 from starlette.routing import Mount, Route
 
+from . import chisel
 from .config import RuntimeConfig
 from .sessions import (
     MissingTarget,
@@ -58,8 +59,16 @@ def _env_of(body: dict[str, Any]) -> dict[str, str]:
 
 async def health(request: Request) -> Response:
     m = _manager(request)
+    creds = m.config.credentials
     return JSONResponse(
-        {"ok": True, "mode": m.mode, "active_sessions": m.active_sessions()}
+        {
+            "ok": True,
+            "mode": m.mode,
+            "active_sessions": m.active_sessions(),
+            # Resolved in the service's own environment, which may
+            # override the configured gateway.
+            "gateway": chisel.gateway(creds) if creds else None,
+        }
     )
 
 
@@ -184,6 +193,13 @@ def _error(status: int) -> Any:
     return handler
 
 
+async def _busy(request: Request, exc: Exception) -> Response:
+    assert isinstance(exc, RuntimeBusy)
+    return JSONResponse(
+        {"detail": str(exc), "session_id": exc.session_id}, status_code=409
+    )
+
+
 def create_app(config: RuntimeConfig) -> Starlette:
     app = Starlette(
         routes=[
@@ -219,7 +235,7 @@ def create_app(config: RuntimeConfig) -> Starlette:
             ValueError: _error(400),
             UnknownSession: _error(404),
             MissingTarget: _error(404),
-            RuntimeBusy: _error(409),
+            RuntimeBusy: _busy,
         },
     )
     app.state.manager = SessionManager(config)

{levain_runtime-0.1.4 → levain_runtime-0.1.6}/levain_runtime/sessions.py

@@ -31,7 +31,9 @@ Runner = Callable[..., Awaitable[tuple[int, bytes, bytes]]]
 
 
 class RuntimeBusy(Exception):
-    pass
+    def __init__(self, message: str, *, session_id: str) -> None:
+        super().__init__(message)
+        self.session_id = session_id
 
 
 class UnknownSession(Exception):
@@ -212,8 +214,9 @@ class DirectBackend:
         os.replace(tmp, link)
 
     async def activate(self, meta: SessionMeta) -> None:
-        if self.active not in (None, meta.sid):
-            raise RuntimeBusy("runtime busy")
+        holder = self.active
+        if holder is not None and holder != meta.sid:
+            raise RuntimeBusy("runtime busy", session_id=holder)
         self._point_workspace(Path(meta.workspace_dir))
         self.active = meta.sid
 
@@ -552,7 +555,7 @@ class DockerBackend:
 class SessionManager:
     """Routes session operations to the configured backend."""
 
-    def __init__(self, config: RuntimeConfig) -> None:
+    def __init__(self, config: RuntimeConfig, *, restore: bool = True) -> None:
         self.config = config
         self.store = SessionStore(config.root)
         self.backend: DirectBackend | DockerBackend
@@ -566,7 +569,8 @@ class SessionManager:
             )
         else:
             self.backend = DirectBackend(config.root)
-            self._restore_direct_slot()
+            if restore:
+                self._restore_direct_slot()
 
     def _restore_direct_slot(self) -> None:
         assert isinstance(self.backend, DirectBackend)
@@ -588,6 +592,8 @@ class SessionManager:
         return meta
 
     def active_sessions(self) -> list[str]:
+        if isinstance(self.backend, DirectBackend):
+            return [self.backend.active] if self.backend.active else []
         return [m.sid for m in self.store.all() if m.state == "active"]
 
     async def provision(
@@ -702,9 +708,15 @@ class SessionManager:
             scope="user" if user else "agent",
             user=user,
         )
+        live = set(self.active_sessions())
         for meta in self.store.all():
-            if meta.workspace_dir == str(target) and meta.state == "active":
-                raise RuntimeBusy(f"workspace in use by session {meta.sid}")
+            if meta.workspace_dir == str(target) and (
+                meta.state == "active" or meta.sid in live
+            ):
+                raise RuntimeBusy(
+                    f"workspace in use by session {meta.sid}",
+                    session_id=meta.sid,
+                )
         shutil.rmtree(target, ignore_errors=True)
         target.mkdir(parents=True, exist_ok=True)
 

{levain_runtime-0.1.4 → levain_runtime-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "levain-runtime"
-version = "0.1.4"
+version = "0.1.6"
 description = "Self-hosted runtime for Levain agents: run an agent's nodes on your own machine or container while the platform drives the recipe"
 readme = "README.md"
 license = "Apache-2.0"