monkeybot-cli 0.2.1__py3-none-any.whl

monkeybot_cli/opensandbox_lifecycle.py

@@ -0,0 +1,314 @@
+"""Start OpenSandbox server for ``monkeybot chat`` when sandbox is enabled in config."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import subprocess
+import time
+from pathlib import Path
+from urllib.parse import urlparse
+
+import httpx
+
+_DEFAULT_SERVER_IMAGE = "opensandbox/server:latest"
+_DEFAULT_CONTAINER = "monkeybot-opensandbox"
+# Docker Desktop / first image pull can take well over a few seconds.
+_DEFAULT_DOCKER_WAIT_SECS = 60.0
+_DEFAULT_HEALTH_WAIT_SECS = 60.0
+
+
+def sandbox_section(doc: dict) -> dict:
+    sec = doc.get("sandbox")
+    return sec if isinstance(sec, dict) else {}
+
+
+def is_sandbox_enabled(doc: dict) -> bool:
+    sec = sandbox_section(doc)
+    enabled = sec.get("enabled")
+    if isinstance(enabled, bool):
+        return enabled
+    raw = os.environ.get("SANDBOX_ENABLED", "").strip().lower()
+    return raw in {"true", "1", "on", "yes"}
+
+
+def server_url_from_config(doc: dict) -> str:
+    sec = sandbox_section(doc)
+    url = sec.get("server_url")
+    if isinstance(url, str) and url.strip():
+        return url.strip()
+    env_url = os.environ.get("SANDBOX_SERVER_URL", "").strip()
+    if env_url:
+        return env_url
+    return "http://localhost:18080"
+
+
+def host_port_from_server_url(server_url: str, *, default: int = 18080) -> int:
+    parsed = urlparse(server_url)
+    if parsed.port is not None:
+        return parsed.port
+    return default
+
+
+def _config_sha256(config_path: Path) -> str:
+    if not config_path.is_file():
+        return ""
+    digest = hashlib.sha256(config_path.read_bytes()).hexdigest()
+    return digest
+
+
+def _health_ok(host_port: int) -> bool:
+    url = f"http://127.0.0.1:{host_port}/health"
+    try:
+        resp = httpx.get(url, timeout=2.0)
+        body = resp.text
+    except httpx.HTTPError:
+        return False
+    return '"status"' in body and "healthy" in body
+
+
+def _server_image() -> str:
+    """OpenSandbox *control plane* image (not the session/worker ``SANDBOX_IMAGE``).
+
+    ``sandbox.image`` / ``SANDBOX_IMAGE`` is the container image for agent
+    ``run_command`` sessions. Reusing it here starts a worker that exits
+    immediately and then burns the full health-wait timeout.
+    """
+    for key in ("SANDBOX_SERVER_IMAGE", "OPENSANDBOX_SERVER_IMAGE"):
+        raw = os.environ.get(key, "").strip()
+        if raw:
+            return raw
+    return _DEFAULT_SERVER_IMAGE
+
+
+def _wait_healthy(
+    host_port: int,
+    *,
+    timeout_secs: float,
+    container: str | None = None,
+) -> bool:
+    deadline = time.monotonic() + timeout_secs
+    while time.monotonic() < deadline:
+        if _health_ok(host_port):
+            return True
+        # Dead container will never become healthy — don't burn the full wait.
+        if container and _container_exists(container) and not _container_running(container):
+            return False
+        time.sleep(0.5)
+    return False
+
+
+def _docker(*args: str, check: bool = False) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["docker", *args],
+        check=check,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _docker_available() -> bool:
+    try:
+        proc = _docker("info")
+    except OSError:
+        return False
+    return proc.returncode == 0
+
+
+def _wait_docker_available(*, timeout_secs: float) -> bool:
+    """Retry ``docker info`` until the daemon is up (Docker Desktop cold start)."""
+    if timeout_secs <= 0:
+        return _docker_available()
+    if _docker_available():
+        return True
+    print(
+        f"monkeybot chat: waiting up to {timeout_secs:.0f}s for Docker…",
+        flush=True,
+    )
+    deadline = time.monotonic() + timeout_secs
+    while time.monotonic() < deadline:
+        time.sleep(1.0)
+        if _docker_available():
+            return True
+    return False
+
+
+def _container_running(name: str) -> bool:
+    proc = _docker("container", "inspect", "-f", "{{.State.Running}}", name)
+    return proc.returncode == 0 and proc.stdout.strip() == "true"
+
+
+def _container_exists(name: str) -> bool:
+    proc = _docker("container", "inspect", name)
+    return proc.returncode == 0
+
+
+def _published_port(name: str) -> str:
+    proc = _docker("port", name, "8080/tcp")
+    if proc.returncode != 0:
+        return ""
+    return proc.stdout.strip()
+
+
+def _config_mount_ok(name: str) -> bool:
+    proc = _docker(
+        "container",
+        "inspect",
+        name,
+        "--format",
+        "{{range .Mounts}}{{.Destination}};{{end}}",
+    )
+    if proc.returncode != 0:
+        return False
+    return "/etc/opensandbox/config.toml" in proc.stdout
+
+
+def _container_config_label(name: str) -> str:
+    proc = _docker(
+        "container",
+        "inspect",
+        name,
+        "--format",
+        '{{index .Config.Labels "mb.opensandbox.config_sha256"}}',
+    )
+    if proc.returncode != 0:
+        return ""
+    return proc.stdout.strip()
+
+
+def _remove_container(name: str) -> None:
+    _docker("rm", "-f", name)
+
+
+def _start_existing(name: str) -> None:
+    _docker("start", name)
+
+
+def _run_container(
+    *,
+    name: str,
+    host_port: int,
+    config_path: Path,
+    image: str,
+    cfg_hash: str,
+) -> bool:
+    proc = _docker(
+        "run",
+        "-d",
+        "--name",
+        name,
+        "--label",
+        f"mb.opensandbox.config_sha256={cfg_hash}",
+        "--add-host=host.docker.internal:host-gateway",
+        "-p",
+        f"{host_port}:8080",
+        "-e",
+        "OPENSANDBOX_INSECURE_SERVER=YES",
+        "-v",
+        "/var/run/docker.sock:/var/run/docker.sock",
+        "-v",
+        f"{config_path}:/etc/opensandbox/config.toml:ro",
+        image,
+    )
+    return proc.returncode == 0
+
+
+def resolve_opensandbox_config(agent_root: Path) -> Path:
+    return (agent_root / "monkeybot_config" / "opensandbox.docker.toml").resolve()
+
+
+def ensure_opensandbox_for_agent(
+    agent_root: Path,
+    *,
+    server_url: str,
+    skip: bool | None = None,
+) -> bool:
+    """Ensure OpenSandbox server is reachable; start docker container when needed.
+
+    Returns True when health check passes or sandbox is skipped/disabled upstream.
+    """
+    if skip is None:
+        skip = os.environ.get("SKIP_OPENSANDBOX", "").strip() == "1"
+    if skip:
+        return True
+
+    host_port = host_port_from_server_url(server_url)
+    if _health_ok(host_port):
+        return True
+
+    docker_wait_secs = float(
+        os.environ.get("SANDBOX_DOCKER_WAIT_SECS", str(_DEFAULT_DOCKER_WAIT_SECS))
+    )
+    if not _wait_docker_available(timeout_secs=docker_wait_secs):
+        print(
+            "monkeybot chat: Docker not available; run_command sandbox will fail "
+            "(set sandbox.enabled: false or start Docker).",
+            flush=True,
+        )
+        return False
+
+    config_path = resolve_opensandbox_config(agent_root)
+    if not config_path.is_file():
+        print(
+            f"monkeybot chat: missing {config_path}; cannot start OpenSandbox.",
+            flush=True,
+        )
+        return False
+
+    container = os.environ.get("SANDBOX_CONTAINER", _DEFAULT_CONTAINER).strip() or _DEFAULT_CONTAINER
+    image = _server_image()
+    wait_secs = float(os.environ.get("SANDBOX_HEALTH_WAIT_SECS", str(_DEFAULT_HEALTH_WAIT_SECS)))
+    want_hash = _config_sha256(config_path)
+
+    if _container_exists(container):
+        published = _published_port(container)
+        port_ok = f":{host_port}" in published
+        if not _config_mount_ok(container) or not port_ok:
+            print(f"monkeybot chat: recreating OpenSandbox container {container}", flush=True)
+            _remove_container(container)
+        elif want_hash and _container_config_label(container) != want_hash:
+            print(f"monkeybot chat: recreating OpenSandbox (config changed)", flush=True)
+            _remove_container(container)
+        elif not _container_running(container):
+            print(f"monkeybot chat: starting OpenSandbox container {container}", flush=True)
+            _start_existing(container)
+
+    if _container_exists(container):
+        if _wait_healthy(host_port, timeout_secs=wait_secs, container=container):
+            return True
+        print("monkeybot chat: OpenSandbox unhealthy; recreating container", flush=True)
+        _remove_container(container)
+
+    print(
+        f"monkeybot chat: starting OpenSandbox ({image}, port {host_port})…",
+        flush=True,
+    )
+    if not _run_container(
+        name=container,
+        host_port=host_port,
+        config_path=config_path,
+        image=image,
+        cfg_hash=want_hash,
+    ):
+        print(
+            f"monkeybot chat: docker run failed (is port {host_port} in use?)",
+            flush=True,
+        )
+        return False
+
+    if _wait_healthy(host_port, timeout_secs=wait_secs, container=container):
+        print(f"monkeybot chat: OpenSandbox ready (127.0.0.1:{host_port})", flush=True)
+        return True
+
+    if _container_exists(container) and not _container_running(container):
+        print(
+            "monkeybot chat: OpenSandbox container exited before becoming healthy "
+            f"(image={image}).",
+            flush=True,
+        )
+    else:
+        print(
+            f"monkeybot chat: OpenSandbox did not become healthy within {wait_secs:.0f}s.",
+            flush=True,
+        )
+    return False

monkeybot_cli/output.py

@@ -0,0 +1,110 @@
+"""Structured JSON output for validate/doctor commands."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from typing import Any, Literal
+
+Severity = Literal["error", "warning"]
+Status = Literal["pass", "fail", "skip"]
+
+
+@dataclass
+class CheckResult:
+    id: str
+    category: str
+    severity: Severity
+    status: Status
+    message: str = ""
+    field: str | None = None
+    value: Any = None
+    expected: list[str] | None = None
+    remediation: str | None = None
+    docs: str | None = None
+
+
+@dataclass
+class CommandReport:
+    command: str
+    ok: bool
+    config_path: str | None
+    checks: list[CheckResult] = field(default_factory=list)
+
+    @property
+    def summary(self) -> dict[str, int]:
+        passed = warnings = failed = skipped = 0
+        for c in self.checks:
+            if c.status == "pass":
+                passed += 1
+            elif c.status == "fail":
+                if c.severity == "error":
+                    failed += 1
+                else:
+                    warnings += 1
+            elif c.status == "skip":
+                skipped += 1
+        return {"passed": passed, "warnings": warnings, "failed": failed, "skipped": skipped}
+
+    def compute_ok(self) -> None:
+        self.ok = not any(c.severity == "error" and c.status == "fail" for c in self.checks)
+
+    def to_dict(self) -> dict[str, Any]:
+        self.compute_ok()
+        return {
+            "command": self.command,
+            "ok": self.ok,
+            "config_path": self.config_path,
+            "checks": [asdict(c) for c in self.checks],
+            "summary": self.summary,
+        }
+
+    def print_human(self) -> None:
+        self.compute_ok()
+        status = "OK" if self.ok else "FAILED"
+        print(f"{self.command}: {status}")
+        if self.config_path:
+            print(f"  config: {self.config_path}")
+        for c in self.checks:
+            if c.status == "skip":
+                continue
+            icon = "✓" if c.status == "pass" else "!"
+            print(f"  [{icon}] {c.id}: {c.message or c.status}")
+            if c.remediation and c.status == "fail":
+                print(f"      → {c.remediation}")
+        s = self.summary
+        print(f"  summary: {s['passed']} passed, {s['warnings']} warnings, {s['failed']} failed, {s['skipped']} skipped")
+
+    def emit(self, *, as_json: bool) -> int:
+        self.compute_ok()
+        if as_json:
+            print(json.dumps(self.to_dict(), indent=2))
+        else:
+            self.print_human()
+        if self.ok:
+            return 0
+        return 1
+
+
+def check(
+    report: CommandReport,
+    *,
+    id: str,
+    category: str,
+    severity: Severity,
+    passed: bool,
+    message: str = "",
+    skip: bool = False,
+    **extra: Any,
+) -> None:
+    status: Status = "skip" if skip else ("pass" if passed else "fail")
+    report.checks.append(
+        CheckResult(
+            id=id,
+            category=category,
+            severity=severity,
+            status=status,
+            message=message,
+            **{k: v for k, v in extra.items() if k in CheckResult.__dataclass_fields__},
+        )
+    )

monkeybot_cli/providers.py

@@ -0,0 +1,112 @@
+"""Provider → extra → credential mapping (owned by CLI)."""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+from dataclasses import dataclass
+
+from monkeybot.core.config import normalize_model_provider
+
+
+@dataclass(frozen=True)
+class ProviderSpec:
+    yaml_aliases: tuple[str, ...]
+    extra: str | None
+    credential_env_vars: tuple[str, ...]
+    gcp_adc: bool = False
+    # True when the provider needs no API key (e.g. a local server reachable
+    # without auth, such as Ollama). Skips the credentials check in `doctor`.
+    credentials_optional: bool = False
+
+
+PROVIDER_SPECS: dict[str, ProviderSpec] = {
+    "google_vertexai": ProviderSpec(
+        ("gemini", "vertex", "google_vertexai"),
+        "gemini",
+        (
+            "GEMINI_API_KEY",
+            "GOOGLE_APPLICATION_CREDENTIALS",
+            "GCP_PROJECT_ID",
+            "GOOGLE_CLOUD_PROJECT",
+        ),
+        gcp_adc=True,
+    ),
+    "openai": ProviderSpec(("openai",), "openai", ("OPENAI_API_KEY",)),
+    "anthropic": ProviderSpec(("anthropic",), "claude", ("ANTHROPIC_API_KEY",)),
+    "vertex_anthropic": ProviderSpec(
+        ("vertex-claude", "vertex_claude", "vertex_anthropic"),
+        "vertex-claude",
+        ("GCP_PROJECT_ID", "GOOGLE_CLOUD_PROJECT", "ANTHROPIC_VERTEX_PROJECT_ID"),
+        gcp_adc=True,
+    ),
+    "aws_bedrock": ProviderSpec(
+        ("aws_bedrock",),
+        "bedrock",
+        ("AWS_ACCESS_KEY_ID", "AWS_PROFILE", "AWS_REGION", "AWS_DEFAULT_REGION"),
+    ),
+    "huggingface": ProviderSpec(
+        ("huggingface",), "huggingface", ("HF_TOKEN", "HUGGINGFACE_API_KEY")
+    ),
+    "nvidia": ProviderSpec(("nvidia",), "nvidia", ("NVIDIA_API_KEY",)),
+    "ollama": ProviderSpec(
+        # credential_env_vars is empty: credentials_optional=True short-circuits
+        # credentials_present() before these are ever read, and OLLAMA_BASE_URL
+        # isn't a credential anyway (it's just the server address).
+        ("ollama",),
+        "ollama",
+        (),
+        credentials_optional=True,
+    ),
+    "fake": ProviderSpec(("fake",), None, (), credentials_optional=True),
+}
+
+
+def canonical_provider(yaml_provider: str) -> str:
+    return normalize_model_provider(yaml_provider.strip().lower())
+
+
+def spec_for_provider(yaml_provider: str) -> ProviderSpec | None:
+    key = canonical_provider(yaml_provider)
+    return PROVIDER_SPECS.get(key)
+
+
+def extra_module(extra: str) -> str:
+    """Return the importable module name used to detect ``extra``."""
+    mapping = {
+        "gemini": "google.genai",
+        "vertex": "google.auth",
+        "claude": "anthropic",
+        "vertex-claude": "anthropic",
+        "openai": "openai",
+        "bedrock": "boto3",
+        "huggingface": "openai",
+        "ollama": "openai",
+        "nvidia": "openai",
+    }
+    return mapping.get(extra, extra)
+
+
+def extra_installed(extra: str) -> bool:
+    """Check ``extra`` in the *current* process (the CLI env).
+
+    Prefer running the check in the interpreter that will host the gateway
+    (see ``monkeybot_cli.runtime_python``) so provider/storage extras declared
+    on the agent project are detected, not the CLI's globals.
+    """
+    return importlib.util.find_spec(extra_module(extra)) is not None
+
+
+def credentials_present(spec: ProviderSpec) -> bool:
+    if spec.credentials_optional:
+        return True
+    if spec.gcp_adc:
+        if os.environ.get("GOOGLE_APPLICATION_CREDENTIALS", "").strip():
+            return True
+        for var in ("GCP_PROJECT_ID", "GOOGLE_CLOUD_PROJECT", "VERTEX_AI_PROJECT_ID"):
+            if os.environ.get(var, "").strip():
+                return True
+        if os.environ.get("GEMINI_API_KEY", "").strip():
+            return True
+        return False
+    return any(os.environ.get(v, "").strip() for v in spec.credential_env_vars)

monkeybot_cli/realtime/__init__.py

@@ -0,0 +1,13 @@
+"""Realtime talk session controller (WebSocket gateway)."""
+
+from __future__ import annotations
+
+from monkeybot_cli.realtime.session import run_talk_session
+from monkeybot_cli.realtime.session_controller import RealtimeSessionController
+from monkeybot_cli.realtime.wire_encode import encode_client_frame
+
+__all__ = [
+    "RealtimeSessionController",
+    "encode_client_frame",
+    "run_talk_session",
+]

monkeybot_cli/realtime/audio_io.py

@@ -0,0 +1,147 @@
+"""Audio input/output helpers for the realtime CLI.
+
+PyAudio is an optional dependency. If it is not installed, the CLI falls back to
+text-only mode. The `pyaudio` package requires PortAudio system libraries.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterator
+from typing import cast
+
+logger = logging.getLogger(__name__)
+
+
+try:
+    import pyaudio
+
+    _HAS_PYAUDIO = True
+except ImportError:
+    pyaudio = None
+    _HAS_PYAUDIO = False
+
+
+class AudioIOError(Exception):
+    """Audio hardware or PyAudio configuration problem."""
+
+
+class AudioRecorder:
+    """Blocking microphone recorder. Run in a thread for async use."""
+
+    def __init__(
+        self,
+        sample_rate: int = 24000,
+        channels: int = 1,
+        chunk_ms: int = 200,
+        format_name: str = "pcm_s16le",
+    ) -> None:
+        if not _HAS_PYAUDIO:
+            raise AudioIOError("PyAudio is not installed. Install 'monkeybot[cli-realtime]'.")
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.chunk_ms = chunk_ms
+        self.format_name = format_name
+        self._format = pyaudio.paInt16 if "s16" in format_name else pyaudio.paInt8
+        self._bytes_per_sample = 2 if "s16" in format_name else 1
+        self._chunk_frames = int(sample_rate * chunk_ms / 1000)
+        self._chunk_bytes = self._chunk_frames * self._bytes_per_sample * channels
+        try:
+            self._pyaudio = pyaudio.PyAudio()
+            self._stream = self._pyaudio.open(
+                format=self._format,
+                channels=channels,
+                rate=sample_rate,
+                input=True,
+                frames_per_buffer=self._chunk_frames,
+            )
+        except Exception as exc:
+            raise AudioIOError(f"Failed to open microphone: {exc}") from exc
+        logger.info(
+            "audio recorder opened: rate=%s channels=%s chunk_ms=%s",
+            sample_rate,
+            channels,
+            chunk_ms,
+        )
+
+    def read_chunk(self) -> bytes:
+        try:
+            return cast(bytes, self._stream.read(self._chunk_frames, exception_on_overflow=False))
+        except Exception as exc:
+            raise AudioIOError(f"Microphone read failed: {exc}") from exc
+
+    def chunk_peak_db(self, chunk: bytes) -> float:
+        """Return approximate peak level of a PCM s16le chunk in dBFS."""
+        import math
+        import struct
+
+        if not chunk or self._bytes_per_sample != 2:
+            return -96.0
+        count = len(chunk) // 2
+        if count == 0:
+            return -96.0
+        peak = 0
+        # Unpack every 16-bit sample and find max absolute value.
+        for i in range(0, len(chunk) - 1, 2):
+            sample = struct.unpack("<h", chunk[i : i + 2])[0]
+            abs_sample = abs(sample)
+            if abs_sample > peak:
+                peak = abs_sample
+        if peak == 0:
+            return -96.0
+        return 20.0 * math.log10(peak / 32768.0)
+
+    def iter_chunks(self) -> Iterator[bytes]:
+        while True:
+            yield self.read_chunk()
+
+    def close(self) -> None:
+        try:
+            self._stream.stop_stream()
+            self._stream.close()
+        except Exception:
+            logger.exception("audio recorder close failed")
+        finally:
+            self._pyaudio.terminate()
+
+
+class AudioPlayer:
+    """Blocking speaker output. Run in a thread for async use."""
+
+    def __init__(
+        self,
+        sample_rate: int = 24000,
+        channels: int = 1,
+        format_name: str = "pcm_s16le",
+    ) -> None:
+        if not _HAS_PYAUDIO:
+            raise AudioIOError("PyAudio is not installed. Install 'monkeybot[cli-realtime]'.")
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self._format = pyaudio.paInt16 if "s16" in format_name else pyaudio.paInt8
+        try:
+            self._pyaudio = pyaudio.PyAudio()
+            self._stream = self._pyaudio.open(
+                format=self._format,
+                channels=channels,
+                rate=sample_rate,
+                output=True,
+            )
+        except Exception as exc:
+            raise AudioIOError(f"Failed to open speaker: {exc}") from exc
+        logger.info("audio player opened: rate=%s channels=%s", sample_rate, channels)
+
+    def write(self, chunk: bytes) -> None:
+        try:
+            self._stream.write(chunk)
+        except Exception as exc:
+            raise AudioIOError(f"Speaker write failed: {exc}") from exc
+
+    def close(self) -> None:
+        try:
+            self._stream.stop_stream()
+            self._stream.close()
+        except Exception:
+            logger.exception("audio player close failed")
+        finally:
+            self._pyaudio.terminate()