monkeybot-cli 0.2.1__tar.gz → 0.3.0__tar.gz

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/.gitignore

@@ -9,9 +9,6 @@ internal/
 # Local scaffolded harness config (defaults ship in monkeybot-cli scaffold_defaults/)
 /monkeybot_config/
 
-# Demo agent live config (materialized from monkeybot_config_example/ by demo_agent/run.sh)
-demo_agent/monkeybot_config/
-
 # Live eval run artifacts (only evals/baselines/ is versioned)
 /evals/runs/
 
@@ -40,6 +37,7 @@ data/
 htmlcov/
 .mypy_cache/
 .ruff_cache/
+.deepeval/
 
 # macOS
 .DS_Store

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: monkeybot-cli
-Version: 0.2.1
+Version: 0.3.0
 Summary: CLI to create, configure, validate, and chat with monkeybot agents.
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: monkeybot[cli]<3,>=2.1.0
+Requires-Dist: monkeybot-browser-mcp<1,>=0.2.0
+Requires-Dist: monkeybot[cli]<3,>=2.2.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: textual>=8.2.8

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monkeybot-cli"
-version = "0.2.1"
+version = "0.3.0"
 description = "CLI to create, configure, validate, and chat with monkeybot agents."
 requires-python = ">=3.11"
 dependencies = [
     # `cli` pulls realtime + typer so `monkeybot talk` works out of the box (text mode).
     # Audio mic/PTT needs the agent (or this env) to also install monkeybot[cli-realtime].
-    "monkeybot[cli]>=2.1.0,<3",
+    "monkeybot[cli]>=2.2.0,<3",
+    "monkeybot-browser-mcp>=0.2.0,<1",
     "httpx>=0.27.0",
     "pyyaml>=6.0.2",
     "python-dotenv>=1.0.0",
@@ -22,6 +23,7 @@ monkeybot = "monkeybot_cli.main:main"
 
 [tool.uv.sources]
 monkeybot = { path = "..", editable = true }
+monkeybot-browser-mcp = { path = "../integrations/browser-mcp", editable = true }
 
 [dependency-groups]
 dev = [

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/skills/monkeybot/SKILL.md

@@ -85,7 +85,9 @@ monkeybot new --dest /path/to/bot --provider openai --yes
 # monkeybot new --dest /path/to/bot --provider openai --with postgres,sandbox --yes
 ```
 
-Creates `monkeybot_config/`, `workspace/` (file-tool sandbox), `workspace/skills` → `skills/`, `data/memory/`, `.env.example`, `scripts/setup-workspace.sh`, and an agent `pyproject.toml`. Use `--force` only when overwriting is explicitly requested.
+Creates `monkeybot_config/`, read-only `skills/`, writable `workspace/`,
+`data/memory/`, `.env.example`, a Dockerfile, and an agent `pyproject.toml`.
+Use `--force` only when overwriting is explicitly requested.
 
 Then:
 

monkeybot_cli-0.3.0/src/monkeybot_cli/__init__.py

@@ -0,0 +1,8 @@
+"""monkeybot setup CLI — create, configure, validate, and chat with agents."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("monkeybot-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/commands/chat.py

@@ -39,7 +39,10 @@ from monkeybot_cli.config_resolve import (
     resolve_agent_root,
     resolve_config,
 )
-from monkeybot_cli.gateway_health import wait_for_health as _wait_for_health
+from monkeybot_cli.gateway_health import (
+    occupied_gateway_message as _occupied_gateway_message,
+    wait_for_health as _wait_for_health,
+)
 from monkeybot_cli.opensandbox_lifecycle import (
     ensure_opensandbox_for_agent,
     is_sandbox_enabled,
@@ -713,6 +716,10 @@ def run_chat(args: argparse.Namespace) -> int:
                     file=sys.stderr,
                 )
         port = args.port if args.port else _port_from_config(config_path)
+        occupied = _occupied_gateway_message(base, port)
+        if occupied is not None:
+            print(occupied, file=sys.stderr)
+            return 1
         spawned = _spawn_gateway(config_path, agent_root, port)
         proc = spawned.proc
         if not _wait_for_health(base, proc):

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/commands/doctor.py

@@ -5,34 +5,27 @@ from __future__ import annotations
 import argparse
 import json
 import os
-import socket
+import shlex
 import subprocess
 import tomllib
 from pathlib import Path
 
 import httpx
 
+from monkeybot.core.layout import AgentLayout, bootstrap_agent_layout
+from monkeybot.core.tools.sandbox_executor import SandboxConfig
 from monkeybot_cli.config_resolve import (
     load_agent_dotenv,
     load_config_doc,
     resolve_agent_root,
     resolve_config,
 )
+from monkeybot_cli.gateway_health import port_free as _port_free
 from monkeybot_cli.output import CommandReport, check
 from monkeybot_cli.providers import credentials_present, extra_module, spec_for_provider
 from monkeybot_cli.runtime_python import resolve_runtime_python, run_probe
 
 
-def _port_free(port: int) -> bool:
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        try:
-            s.bind(("127.0.0.1", port))
-            return True
-        except OSError:
-            return False
-
-
 def _runtime_python_version(runtime, agent_root: Path) -> tuple[int, int, int]:
     """Ask the runtime interpreter for its version (major, minor, micro)."""
     code = "import sys; print(sys.version_info[0], sys.version_info[1], sys.version_info[2])"
@@ -88,6 +81,105 @@ def _extra_remediation(extra: str, agent_root: Path, runtime) -> str:
     )
 
 
+def _storage_kind(uri: str) -> str:
+    """Render storage kind without leaking URL credentials or filesystem details."""
+    if "://" not in uri:
+        return "unknown"
+    scheme, remainder = uri.split("://", 1)
+    if scheme == "sqlite":
+        return "sqlite"
+    host = remainder.split("@")[-1].split("/")[0]
+    return f"{scheme}://{host}" if host else scheme
+
+
+def _add_layout_checks(report: CommandReport, layout: AgentLayout) -> None:
+    check(
+        report,
+        id="layout.resolved",
+        category="layout",
+        severity="error",
+        passed=True,
+        message="Canonical agent layout resolved",
+        value={
+            "agent_root": str(layout.agent_root),
+            "workspace": str(layout.workspace_root),
+            "skills": str(layout.skills_path),
+            "data": str(layout.data_root),
+            "db": _storage_kind(layout.db_url),
+            "memory": _storage_kind(layout.memory_storage_uri),
+        },
+    )
+
+    legacy_skills = layout.workspace_root / "skills"
+    populated_skills = layout.skills_path.exists() and any(layout.skills_path.iterdir())
+    legacy_exists = legacy_skills.exists() or legacy_skills.is_symlink()
+    collision = legacy_exists and populated_skills
+    source = str(legacy_skills)
+    destination = str(layout.skills_path)
+    check(
+        report,
+        id="layout.legacy_nested_skills",
+        category="layout",
+        severity="warning",
+        passed=not legacy_exists,
+        message=(
+            "Legacy workspace/skills detected"
+            + ("; destination skills/ is populated (resolve collision manually)" if collision else "")
+            if legacy_exists
+            else "No legacy nested skills directory"
+        ),
+        remediation=(
+            "Collision detected: do not move automatically; reconcile the two skill trees first."
+            if collision
+            else (
+                "Preview only (not executed): "
+                f"mv {shlex.quote(source)} {shlex.quote(destination)}"
+            )
+            if legacy_exists
+            else None
+        ),
+        value=(
+            {
+                "source": source,
+                "destination": destination,
+                "collision": collision,
+                "action": None if collision else "mv",
+            }
+            if legacy_exists
+            else None
+        ),
+    )
+
+    browser_enabled = False
+    if layout.mcp_config_path.is_file():
+        try:
+            servers = json.loads(layout.mcp_config_path.read_text(encoding="utf-8")).get("mcpServers", {})
+            browser = servers.get("browser", {}) if isinstance(servers, dict) else {}
+            browser_enabled = bool(browser.get("enabled")) if isinstance(browser, dict) else False
+        except (OSError, json.JSONDecodeError):
+            pass
+    check(
+        report,
+        id="browser.bundled",
+        category="layout",
+        severity="warning",
+        passed=True,
+        message="browser: enabled" if browser_enabled else "browser: disabled (bundled)",
+    )
+
+    sandbox = SandboxConfig.from_env()
+    sandbox_mode = "remote (compute-only)" if not sandbox.shared_filesystem else "shared-filesystem"
+    check(
+        report,
+        id="sandbox.status",
+        category="layout",
+        severity="warning",
+        passed=True,
+        message=f"sandbox: {'enabled' if sandbox.enabled else 'disabled'} ({sandbox_mode})",
+        value={"image": sandbox.image, "mode": sandbox_mode},
+    )
+
+
 def run_doctor(args: argparse.Namespace) -> int:
     cwd = Path(args.cwd).expanduser().resolve() if args.cwd else None
     config_path = resolve_config(args.config, cwd=cwd)
@@ -97,6 +189,14 @@ def run_doctor(args: argparse.Namespace) -> int:
         report.config_path = str(config_path.resolve())
 
     agent_root = resolve_agent_root(cwd=cwd, config_path=config_path)
+    layout = bootstrap_agent_layout(cwd=agent_root, config_path=config_path)
+    _add_layout_checks(report, layout)
+    if not args.json:
+        print("layout:")
+        print(f"  agent_root: {layout.agent_root}")
+        print(f"  workspace: {layout.workspace_root}")
+        print(f"  skills: {layout.skills_path}")
+        print(f"  data: {layout.data_root}")
     runtime = resolve_runtime_python(agent_root)
 
     py_version = _runtime_python_version(runtime, agent_root)

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/commands/run_cmd.py

@@ -20,9 +20,8 @@ def run_run(args: argparse.Namespace) -> int:
         env["MONKEYBOT_CONFIG"] = str(config_path)
     if args.port:
         env["PORT"] = str(args.port)
-    # Derive the agent root from --cwd when given, else from --config so an
-    # off-tree config selects the right project venv / `uv run` cwd — matching
-    # `monkeybot doctor`. Falls back to cwd when neither is provided.
+    # --cwd intentionally pins the subprocess and runtime directory. Without
+    # it, an explicit config determines the agent root.
     agent_root = resolve_agent_root(cwd=cwd, config_path=config_path)
     runtime = resolve_runtime_python(agent_root)
     cmd = gateway_argv(runtime)

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/commands/validate.py

@@ -20,6 +20,7 @@ from monkeybot.core.config import (
 from monkeybot.core.config.runtime_env import ENV_MAP
 from monkeybot.core.config.settings import ConfigError, normalize_model_provider
 from monkeybot.core.config.yaml_loader import load_monkeybot_yaml_dict
+from monkeybot.core.layout import resolve_agent_root
 
 from monkeybot_cli.config_resolve import load_agent_dotenv, resolve_config
 from monkeybot_cli.output import CommandReport, check
@@ -84,7 +85,7 @@ def run_validate(args: argparse.Namespace) -> int:
         return report.emit(as_json=args.json)
 
     report.config_path = str(config_path.resolve())
-    base = config_path.parent.parent if config_path.parent.name == "monkeybot_config" else Path.cwd()
+    base = resolve_agent_root(config_path=config_path)
 
     try:
         raw = config_path.read_text(encoding="utf-8")

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/compat.py

@@ -4,4 +4,4 @@ from __future__ import annotations
 
 # Floor matches published ``monkeybot-cli`` → ``monkeybot[cli]`` bound.
 # Raise together when scaffolding or gateway APIs break compatibility.
-COMPATIBLE_CORE_RANGE = ">=2.1.0,<3"
+COMPATIBLE_CORE_RANGE = ">=2.2.0,<3"

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/config_resolve.py

@@ -9,18 +9,14 @@ from monkeybot.core.config.yaml_loader import (
     load_monkeybot_yaml_dict,
     resolve_monkeybot_config_path,
 )
+from monkeybot.core.layout import resolve_agent_root as _resolve_agent_root
 
 
 def resolve_agent_root(*, cwd: Path | None = None, config_path: Path | None = None) -> Path:
     """Return the agent project root (directory containing monkeybot_config/ or .env)."""
     if cwd is not None:
         return cwd.expanduser().resolve()
-    if config_path is not None:
-        cp = config_path.expanduser().resolve()
-        if cp.parent.name == "monkeybot_config":
-            return cp.parent.parent
-        return cp.parent
-    return Path.cwd()
+    return _resolve_agent_root(config_path=config_path)
 
 
 def load_agent_dotenv(*, cwd: Path | None = None, config_path: Path | None = None) -> Path | None:
@@ -34,10 +30,6 @@ def load_agent_dotenv(*, cwd: Path | None = None, config_path: Path | None = Non
     if env_file.is_file():
         load_dotenv(env_file, override=False)
         return env_file
-    fallback = Path.cwd() / ".env"
-    if fallback.is_file() and fallback != env_file:
-        load_dotenv(fallback, override=False)
-        return fallback
     return None
 
 
@@ -46,8 +38,10 @@ def resolve_config(explicit: str | None, *, cwd: Path | None = None) -> Path | N
     if explicit:
         p = Path(explicit).expanduser()
         return p.resolve() if p.is_file() else None
-    resolved_cwd = cwd.expanduser().resolve() if cwd is not None else None
-    return resolve_monkeybot_config_path(cwd=resolved_cwd)
+    if cwd is not None:
+        candidate = cwd.expanduser().resolve() / "monkeybot_config" / "monkeybot.yaml"
+        return candidate.resolve() if candidate.is_file() else None
+    return resolve_monkeybot_config_path()
 
 
 def load_config_doc(config_path: str | Path | None = None) -> tuple[Path | None, dict]:

monkeybot_cli-0.3.0/src/monkeybot_cli/gateway_health.py

@@ -0,0 +1,71 @@
+"""Gateway health polling helpers shared by chat and talk."""
+
+from __future__ import annotations
+
+import socket
+import subprocess
+import time
+
+import httpx
+
+
+def port_free(port: int, host: str = "127.0.0.1") -> bool:
+    """Return True when ``host:port`` can be bound (nothing listening)."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            s.bind((host, port))
+            return True
+        except OSError:
+            return False
+
+
+def wait_for_health(
+    base: str, proc: subprocess.Popen[str] | None, timeout_s: float = 30.0
+) -> bool:
+    """Poll ``GET {base}/health`` until 200 from *our* child, process dies, or timeout.
+
+    On success we re-check ``proc.poll()`` so a pre-existing listener on the same
+    port cannot satisfy health while our spawn has already exited (failed bind).
+    """
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        if proc is not None and proc.poll() is not None:
+            return False
+        try:
+            resp = httpx.get(f"{base}/health", timeout=2.0)
+            if resp.status_code == 200:
+                if proc is not None and proc.poll() is not None:
+                    return False
+                return True
+        except httpx.HTTPError:
+            pass
+        time.sleep(0.3)
+    return False
+
+
+def health_ok(base: str) -> bool:
+    """Single-shot health check."""
+    try:
+        return httpx.get(f"{base}/health", timeout=2.0).status_code == 200
+    except httpx.HTTPError:
+        return False
+
+
+def occupied_gateway_message(base: str, port: int) -> str | None:
+    """If ``port`` is already taken, return a user-facing error; else ``None``.
+
+    Used before ``monkeybot chat`` spawns a gateway so we never talk to a stale
+    process while the status bar shows the current yaml provider/model.
+    """
+    listening = not port_free(port)
+    healthy = health_ok(base)
+    if not listening and not healthy:
+        return None
+    detail = " (gateway /health OK)" if healthy else ""
+    return (
+        f"Port {port} is already in use{detail}. "
+        f"Another monkeybot process is likely still running at {base}.\n"
+        "Exit that session with /bye, stop `monkeybot run`, or free the port, "
+        "then retry — or connect with `monkeybot chat --attach`."
+    )

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/scaffold.py

@@ -3,8 +3,6 @@
 from __future__ import annotations
 
 import re
-import shutil
-import stat
 from importlib import resources
 from importlib.resources.abc import Traversable
 from pathlib import Path
@@ -26,12 +24,11 @@ _CONFIG_BUNDLE: Final[tuple[tuple[str, str], ...]] = (
     ("command_allowlist.yaml", "command_allowlist.yaml"),
     ("permissions.yaml", "permissions.yaml"),
     ("AGENT.md", "AGENT.md"),
-    ("env.example", "env.example"),
     ("otel-collector.example.yaml", "otel-collector.example.yaml"),
 )
 
 _MEMORY_INDEX: Final = (
-    "# Memory index\n\nAdd sections here or let memory tools populate this file.\n"
+    "# Memory Index\n\nAdd sections here or let memory tools populate this file.\n"
 )
 
 
@@ -115,7 +112,7 @@ def ensure_memory(dest: Path, *, force: bool) -> list[str]:
 
 
 def ensure_workspace(dest: Path, *, force: bool) -> list[str]:
-    """Create workspace/ sandbox and workspace/skills -> ../skills symlink."""
+    """Create the writable workspace and a separate trusted skills root."""
     lines: list[str] = []
     workspace = dest / "workspace"
     workspace.mkdir(parents=True, exist_ok=True)
@@ -129,52 +126,14 @@ def ensure_workspace(dest: Path, *, force: bool) -> list[str]:
         lines.append("  workspace/.gitkeep: skipped")
 
     dest.joinpath("skills").mkdir(parents=True, exist_ok=True)
-    link = workspace / "skills"
-    expected = (dest / "skills").resolve()
-
-    if link.is_symlink():
-        if link.resolve() == expected:
-            lines.append("  workspace/skills: skipped (symlink ok)")
-            return lines
-        link.unlink()
-
-    if link.exists() and not link.is_symlink():
-        if not force:
-            lines.append("  workspace/skills: skipped (path exists)")
-            return lines
-        if link.is_dir():
-            shutil.rmtree(link)
-        else:
-            link.unlink()
-
-    try:
-        link.symlink_to("../skills", target_is_directory=True)
-        lines.append("  workspace/skills: symlink -> ../skills")
-    except OSError:
-        readme = workspace / "SKILLS_README.txt"
-        readme.write_text(
-            "Could not create workspace/skills symlink on this platform.\n"
-            "Run: bash scripts/setup-workspace.sh\n"
-            "Or copy/symlink skills/ into workspace/skills manually.\n",
-            encoding="utf-8",
-        )
-        lines.append("  workspace/skills: symlink failed (see workspace/SKILLS_README.txt)")
-
     return lines
 
 
-def install_setup_script(dest: Path, *, force: bool) -> str:
-    scripts = dest / "scripts"
-    scripts.mkdir(parents=True, exist_ok=True)
-    dest_script = scripts / "setup-workspace.sh"
-    if dest_script.exists() and not force:
-        return "skipped"
-    existed = dest_script.exists()
-    dest_script.write_bytes(
-        (resources.files(_DEFAULTS_PKG) / "setup-workspace.sh").read_bytes()
-    )
-    dest_script.chmod(dest_script.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
-    return "overwritten" if existed else "created"
+def install_browser_skill(dest: Path, *, force: bool) -> str:
+    """Install the bundled, trusted browser procedure into ``skills/browser``."""
+    target = dest / "skills" / "browser" / "SKILL.md"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    return _install_file(target, resources.files(_DEFAULTS_PKG) / "browser" / "SKILL.md", force=force)
 
 
 def install_env_example(dest: Path, *, force: bool) -> str:
@@ -186,6 +145,17 @@ def install_env_example(dest: Path, *, force: bool) -> str:
     return "overwritten" if existed else "created"
 
 
+def install_container_files(dest: Path, *, force: bool) -> list[str]:
+    """Install a deployable agent image definition, never the repo demo image."""
+    files = (("Dockerfile", "Dockerfile"), ("dockerignore", ".dockerignore"))
+    lines: list[str] = []
+    for source, target_name in files:
+        target = dest / target_name
+        status = _install_file(target, resources.files(_DEFAULTS_PKG) / source, force=force)
+        lines.append(f"  {target_name}: {status}")
+    return lines
+
+
 def _sanitize_project_name(raw: str) -> str:
     name = re.sub(r"[^a-z0-9._-]+", "-", raw.strip().lower()).strip("-._")
     return name or "agent"
@@ -244,7 +214,9 @@ def write_agent_pyproject(
     if path.exists() and not force:
         return "skipped"
     existed = path.exists()
-    dep = monkeybot_requirement(provider=provider, extras=extras)
+    # Sandbox is configured in every generated agent, so install its SDK with
+    # the provider dependencies rather than imposing it on every core install.
+    dep = monkeybot_requirement(provider=provider, extras=["sandbox", *(extras or [])])
     name = _sanitize_project_name(dest.name)
     path.write_text(
         (
@@ -254,7 +226,10 @@ def write_agent_pyproject(
             'requires-python = ">=3.11"\n'
             "dependencies = [\n"
             f'  "{dep}",\n'
+            '  "monkeybot-browser-mcp>=0.2.0,<1",\n'
             "]\n"
+            "\n[tool.uv]\n"
+            "package = false\n"
         ),
         encoding="utf-8",
     )
@@ -269,7 +244,7 @@ def run_new(
     model: str | None = None,
     extras: list[str] | None = None,
 ) -> list[str]:
-    """Full scaffold: config bundle, workspace, env example, and setup script."""
+    """Full scaffold: config bundle, trusted skills, writable state, and image files."""
     cfg_dir = dest / "monkeybot_config"
     report = install_config_bundle(cfg_dir, force=force)
     report.append(
@@ -278,8 +253,9 @@ def run_new(
     )
     report.extend(ensure_memory(dest, force=force))
     report.extend(ensure_workspace(dest, force=force))
-    report.append(f"  scripts/setup-workspace.sh: {install_setup_script(dest, force=force)}")
+    report.append(f"  skills/browser/SKILL.md: {install_browser_skill(dest, force=force)}")
     report.append(f"  .env.example: {install_env_example(dest, force=force)}")
+    report.extend(install_container_files(dest, force=force))
     report.append(
         f"  pyproject.toml: "
         f"{write_agent_pyproject(dest, provider=provider, extras=extras, force=force)}"

monkeybot_cli-0.3.0/src/monkeybot_cli/scaffold_defaults/Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.12-slim
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+WORKDIR /agent
+
+COPY pyproject.toml uv.lock ./
+RUN uv sync --frozen --no-dev
+
+ARG INSTALL_CHROMIUM=0
+USER root
+RUN if [ "$INSTALL_CHROMIUM" = "1" ]; then \
+      apt-get update && apt-get install -y --no-install-recommends chromium \
+      && rm -rf /var/lib/apt/lists/*; \
+    fi
+
+COPY monkeybot_config ./monkeybot_config
+COPY skills ./skills
+RUN useradd --create-home agent \
+    && mkdir -p workspace data/memory \
+    && chown -R agent:agent workspace data
+
+USER agent
+ENV PATH="/agent/.venv/bin:$PATH" PORT=8080
+EXPOSE 8080
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health')"
+CMD ["python", "-m", "monkeybot.gateway.main"]

monkeybot_cli-0.3.0/src/monkeybot_cli/scaffold_defaults/browser/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: browser
+description: Control a real browser through the optional bundled browser MCP server.
+---
+
+# Browser
+
+When browser tools are needed, call `enable_mcp("browser")` first. The server is
+bundled with every scaffold but is disabled by default in `monkeybot_config/mcp.json`.
+
+Use indexed DOM tools before screenshots. Browser screenshots and agent-written
+playbooks are workspace data: `browser/Screenshots/` and `browser/playbooks/`.
+They are not trusted skills and may be discarded with an ephemeral workspace.
+
+Finish browser sessions with `browser_stop`.

monkeybot_cli-0.3.0/src/monkeybot_cli/scaffold_defaults/dockerignore

@@ -0,0 +1,5 @@
+workspace/
+data/
+.env
+.venv/
+.git/

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/scaffold_defaults/env.example

@@ -1,6 +1,7 @@
 # Copy to .env and fill in secrets / machine-local values only.
 
 # Conversation history — SQLite is fine for single-agent dev.
+# Relative paths in monkeybot.yaml are already anchored to this agent root.
 DB_URL=sqlite:///data/monkeybot.db
 # DB_URL=postgresql://postgres:postgres@localhost:5432/monkeybot
 # DB_URL=firestore://your-gcp-project/(default)

{monkeybot_cli-0.2.1 → monkeybot_cli-0.3.0}/src/monkeybot_cli/scaffold_defaults/mcp.json

@@ -30,18 +30,15 @@
       }
     },
     "browser": {
-      "command": "uv",
+      "enabled": false,
+      "command": "${MONKEYBOT_PYTHON}",
       "args": [
-        "run",
-        "--project",
-        "/path/to/monkeybot/integrations/browser-mcp",
-        "python",
         "-m",
         "browser_mcp.server"
       ],
       "env": {
         "BU_NAME": "monkeybot",
-        "BROWSER_MCP_PLAYBOOKS_DIR": "./workspace/skills/browser/playbooks",
+        "BROWSER_MCP_PLAYBOOKS_DIR": "${MONKEYBOT_WORKSPACE_ROOT}/browser/playbooks",
         "BROWSER_MCP_SCREENSHOTS_DIR": "${MONKEYBOT_WORKSPACE_ROOT}/browser/Screenshots"
       }
     }