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

{levain_runtime-0.1.2 → levain_runtime-0.1.4}/.gitignore

@@ -18,6 +18,10 @@ build/
 !**/platform_agents/build/
 !**/src/build/
 
+# Maven build output
+services/flink/target/
+services/flink/dependency-reduced-pom.xml
+
 # Binaries
 bin/
 
@@ -136,3 +140,6 @@ assets/video/*/renders/
 # www/public/videos/, the composition that made them does not.
 assets/video/updates-*/
 assets/video/*/snapshots/
+
+# Maven build output (Flink job); the image build compiles from source.
+services/flink/target/

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: levain-runtime
-Version: 0.1.2
+Version: 0.1.4
 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.2 → levain_runtime-0.1.4}/levain_runtime/chisel.py

@@ -90,6 +90,15 @@ def server_url(gateway_url: str) -> str:
     return gateway_url
 
 
+def gateway(creds: Credentials) -> str:
+    """The gateway to dial: the platform's, unless this host overrides it.
+
+    A runner on the platform cluster's own node dials the gateway Service
+    directly instead of looping out through the public edge and back.
+    """
+    return os.environ.get("LEVAIN_RUNTIME_GATEWAY_URL") or creds.gateway_url
+
+
 def client_argv(binary: Path, creds: Credentials) -> list[str]:
     remotes = [f"R:{creds.reverse_port}:127.0.0.1:{RUNNER_HTTP_PORT}"]
     remotes += [f"{f.local_port}:{f.remote}" for f in creds.forwards]
@@ -102,7 +111,7 @@ def client_argv(binary: Path, creds: Credentials) -> list[str]:
         # default lets the reconnect wait grow to five minutes.
         "--max-retry-interval",
         "30s",
-        server_url(creds.gateway_url),
+        server_url(gateway(creds)),
         *remotes,
     ]
 

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

@@ -9,6 +9,7 @@ import os
 import shlex
 import subprocess
 import sys
+import time
 from importlib import resources
 from pathlib import Path
 from typing import Annotated
@@ -283,6 +284,82 @@ def register(
     print("next: levain-runtime up")
 
 
+def _detach_and_send(
+    root: Path,
+    creds: Credentials,
+    event_type: str,
+    payload: object,
+    agent: str | None,
+) -> None:
+    """Deliver an event from a detached child; the caller returns now.
+
+    A hook must never wait on the network, so the parent forks and
+    exits while the child drops the inherited stdio (a caller reading
+    our pipes would otherwise block on the child) and posts the event.
+    Failures land in ``emit.log`` under the runtime home.
+    """
+    if os.fork() > 0:
+        return
+    os.setsid()
+    devnull = os.open(os.devnull, os.O_RDWR)
+    for fd in (0, 1, 2):
+        os.dup2(devnull, fd)
+    try:
+        platform_api.post_event(creds, event_type, payload, agent)
+    except Exception as exc:  # nothing above us to handle it
+        with (root / "emit.log").open("a") as fh:
+            fh.write(
+                f"{time.strftime('%Y-%m-%dT%H:%M:%S%z')} {event_type}: {exc}\n"
+            )
+    finally:
+        os._exit(0)
+
+
+@app.command()
+def emit(
+    event_type: Annotated[
+        str,
+        typer.Argument(help="Event name, e.g. runtime.claude_code.stop"),
+    ],
+    agent: Annotated[
+        str | None,
+        typer.Option(help="Only dispatch this agent (slug)"),
+    ] = None,
+    payload: Annotated[
+        str | None,
+        typer.Option(help="JSON payload, or - to read it from stdin"),
+    ] = None,
+    wait: Annotated[
+        bool,
+        typer.Option(
+            "--wait", help="Send in the foreground and print the result"
+        ),
+    ] = False,
+) -> None:
+    """Raise an event for agents subscribed to it on this runtime.
+
+    Reads the payload, then returns immediately while a detached child
+    delivers it — safe to call from hooks. Use --wait to send in the
+    foreground and see the platform's response.
+    """
+    config = _load_config()
+    creds = config.credentials
+    if creds is None:
+        raise typer.BadParameter(
+            "no credentials; run `levain-runtime connect`"
+        )
+    raw = sys.stdin.read() if payload == "-" else payload
+    try:
+        parsed = json.loads(raw) if raw and raw.strip() else None
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"payload is not valid JSON: {exc}") from None
+    if wait or not hasattr(os, "fork"):
+        result = platform_api.post_event(creds, event_type, parsed, agent)
+        print(json.dumps(result))
+        return
+    _detach_and_send(config.root, creds, event_type, parsed, agent)
+
+
 @app.command()
 def up() -> None:
     """Start the node server, the tunnel and the heartbeat."""
@@ -305,7 +382,7 @@ def status() -> None:
     )
     if config.credentials:
         print(f"runtime: {config.credentials.runtime_id}")
-        print(f"gateway: {config.credentials.gateway_url}")
+        print(f"gateway: {chisel.gateway(config.credentials)}")
     else:
         print("runtime: not connected")
     if config.mode == "direct":

{levain_runtime-0.1.2 → levain_runtime-0.1.4}/levain_runtime/platform_api.py

@@ -50,6 +50,35 @@ def refresh_connection(creds: Credentials) -> bool:
     return True
 
 
+def post_event(
+    creds: Credentials,
+    event_type: str,
+    payload: Any,
+    agent: str | None = None,
+) -> dict[str, Any]:
+    """``POST /api/v1/runtimes/{id}/events``; returns the response body.
+
+    Raises ``httpx.HTTPStatusError`` with the API's message on refusal.
+    """
+    body: dict[str, Any] = {"event_type": event_type, "payload": payload}
+    if agent is not None:
+        body["agent"] = agent
+    with _client() as client:
+        resp = client.post(
+            f"{creds.api_url}/api/v1/runtimes/{creds.runtime_id}/events",
+            json=body,
+            headers={"Authorization": f"Bearer {creds.secret}"},
+        )
+    if resp.status_code >= 400:
+        raise httpx.HTTPStatusError(
+            _error_message(resp), request=resp.request, response=resp
+        )
+    data = resp.json()
+    if not isinstance(data, dict):
+        raise ValueError("unexpected response from the platform")
+    return data
+
+
 def register_runtime(
     api_url: str, api_key: str, body: dict[str, Any]
 ) -> dict[str, Any]:

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

@@ -1,6 +1,6 @@
 [project]
 name = "levain-runtime"
-version = "0.1.2"
+version = "0.1.4"
 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"