monkeybot 3.6.1__tar.gz → 3.7.0__tar.gz

{monkeybot-3.6.1 → monkeybot-3.7.0}/CHANGELOG.md

@@ -6,6 +6,25 @@ the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [core v3.7.0] - 2026-09-30
+
+### Added
+
+- `run_command` can start a long command in the background and return `job_id` and `log_path` immediately. `await_command` pages its output until it exits, and `kill_command` stops it, on the local terminal and in the OpenSandbox executor. A turn cannot finish while a job is still running; leftover jobs are killed when the turn ends. The sandbox renews its lease while a job runs, up to the job time ceiling.
+
+## [browser v0.8.1] - 2026-09-28
+
+### Fixed
+
+- The per-chat browser IPC router honors browser-harness 0.1.13's response timeout, so browser tools can drive the page again.
+
+## [browser v0.8.0] - 2026-09-27
+
+### Added
+
+- Each Spaces chat gets its own browser daemon, tab registry, and lock, so simultaneous chats no longer restart each other or drop tab aliases. Local Chrome and AgentCore stay on one shared browser. An idle daemon stops after 15 minutes and keeps that chat's tab aliases for the next call.
+- The per-chat tab cap is 10. When Spaces refuses a tab because the app-wide live-tab cap is full, the tool returns `tab_limit_reached` with `"scope": "app"` instead of this chat's limit.
+
 ## [core v3.6.1] - 2026-09-26
 
 ### Fixed

{monkeybot-3.6.1 → monkeybot-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: monkeybot
-Version: 3.6.1
+Version: 3.7.0
 Summary: monkeybot agent harness — FastAPI SSE gateway, owned loop, SQLite, and MCP.
 License: MIT
 License-File: LICENSE

{monkeybot-3.6.1 → monkeybot-3.7.0}/cli/src/monkeybot_cli/scaffold_defaults/browser/SKILL.md

@@ -34,8 +34,9 @@ only. Pass `expected_origin` so a login cannot land on the wrong site, and check
 the returned `origin` before reporting success.
 
 Tabs use aliases (`t1`, `t2`, …). Reads (`get_elements`, `page_info`, `js`,
-`read_tabs`) never move focus; actions do. At most five agent-controlled tabs —
-if you hit the cap, ask the user which to close, then `browser_close_tab`. Close
+`read_tabs`) never move focus; actions do. At most 10 agent-controlled tabs —
+if you hit the cap, ask the user which to close, then `browser_close_tab`. If the
+error scope is `app`, the Spaces window is full across chats, not this chat's cap. Close
 tabs you opened. `browser_login` still targets the tab the user has focused.
 
 Finish browser sessions with `browser_stop`.

{monkeybot-3.6.1 → monkeybot-3.7.0}/cli/src/monkeybot_cli/scaffold_defaults/monkeybot.example.yaml

@@ -241,6 +241,14 @@ sandbox:
   server_url: http://localhost:18080
   image: python:3.12
   ttl_seconds: 1800
+  # Background command caps. Jobs longer than max_job_seconds fail and should
+  # move to a broker-owned build. renew_interval_seconds extends the worker
+  # while a job is running (0 renews once at start). await_* bounds await_command.
+  max_background_jobs: 4
+  max_job_seconds: 3300
+  renew_interval_seconds: 300
+  await_default_wait_seconds: 300
+  await_max_wait_seconds: 600
   # Set false only for a remote sandbox server with no shared filesystem. It
   # then runs compute-only commands and refuses workspace/skills file access.
   shared_filesystem: true

{monkeybot-3.6.1 → monkeybot-3.7.0}/docs/browser-mcp.md

@@ -191,9 +191,14 @@ synchronization layer.
 
 ## In-app bridge extensions
 
-When the Spaces in-app browser is bound, each tool call may announce which chat
-it is acting for so new tabs stay attached to that chat. AgentCore and Browser
-Use Cloud backends never send this.
+When the Spaces in-app browser is bound, each chat gets its own harness daemon
+and tab list (10 agent tabs). The daemon's CDP URL carries `run` and `chat`,
+and the first bind also announces the chat for older apps. AgentCore and
+Browser Use Cloud backends never send this and stay on one shared browser.
+An idle chat's daemon stops after 15 minutes; its tab aliases stay so the next
+call can reattach. If Spaces refuses a tab because the app-wide live-tab cap
+is full, the tool returns `tab_limit_reached` with `"scope": "app"` (CDP error
+code `-32010`) instead of this chat's limit of 10.
 
 ### MCP request meta
 
@@ -208,7 +213,7 @@ server then announces `chatKey` as `null`.
 
 ### `Monkeybot.setChatScope`
 
-On every in-app tool call, after the harness binds and before other CDP
+Once per daemon connection, after the harness binds and before other CDP
 commands, the backend sends:
 
 ```json

{monkeybot-3.6.1 → monkeybot-3.7.0}/examples/skills/browser/SKILL.md

@@ -67,7 +67,7 @@ Text-only models should never rely on screenshots for page understanding — use
 
 Tabs have short aliases (`t1`, `t2`, …) or a name you pass to `browser_open_tab(alias=...)`. **Reads never move focus** (`browser_get_elements(tab=...)`, `browser_page_info`, `browser_js`, `browser_wait_for`, `browser_read_tabs`, `browser_extract`). **Actions do** (click, input, select, fill, fill_form, click_text, act, screenshot, …) because headed Chrome throttles timers and pauses painting in background tabs.
 
-Open a second tab to compare pages, keep a form while reading docs, or fan out with `browser_read_tabs`. At most five agent-controlled tabs (`BROWSER_MCP_MAX_TABS`). If you hit the cap, relay the returned list (aliases, titles, last-used) to the user, ask which to close, then `browser_close_tab` and retry — never close a tab without their confirmation. Close tabs you opened when done. Do not expect a background SPA to finish loading while unfocused. `browser_login` still targets the tab the **user** has focused, not `tab=`.
+Open a second tab to compare pages, keep a form while reading docs, or fan out with `browser_read_tabs`. At most 10 agent-controlled tabs (`BROWSER_MCP_MAX_TABS`). If you hit the cap, relay the returned list (aliases, titles, last-used) to the user, ask which to close, then `browser_close_tab` and retry — never close a tab without their confirmation. If the error scope is `app`, the Spaces window is full across chats; do not describe that as this chat's 10-tab cap. Close tabs you opened when done. Do not expect a background SPA to finish loading while unfocused. `browser_login` still targets the tab the **user** has focused, not `tab=`.
 
 ## After learning something non-obvious
 

{monkeybot-3.6.1 → monkeybot-3.7.0}/integrations/browser-mcp/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monkeybot-browser-mcp"
-version = "0.7.2"
+version = "0.8.1"
 description = "monkeybot MCP server wrapping browser-harness for real-browser control and site playbooks."
 requires-python = ">=3.11"
 dependencies = [

{monkeybot-3.6.1 → monkeybot-3.7.0}/integrations/browser-mcp/src/browser_mcp/app.py

@@ -4,18 +4,17 @@ from __future__ import annotations
 
 import functools
 import inspect
-import threading
 from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, ParamSpec
 
+import anyio
 from mcp.server.fastmcp import FastMCP
 
-from browser_mcp import backend, in_app_cdp, perf, results, tab_ops, tabs
+from browser_mcp import backend, chat_context, chat_scope, in_app_cdp, perf, results, tab_ops, tabs
 from browser_mcp.observe import resolve_action_observe
 
 _P = ParamSpec("_P")
-_TOOL_LOCK = threading.RLock()
 
 mcp = FastMCP(
     "browser",
@@ -73,15 +72,34 @@ mcp = FastMCP(
         "Actions (click, input, select, fill, click_text, act, screenshot, …) focus the tab first "
         "because background tabs throttle timers and pause painting. Open a second "
         "tab to compare pages, keep a form while reading docs, or fan out with "
-        "browser_read_tabs. At most five agent-controlled tabs; if you hit the cap, "
+        "browser_read_tabs. At most 10 agent-controlled tabs; if you hit the cap, "
         "relay the returned tab list to the user, ask which to close, then "
         "browser_close_tab and retry — never close a tab without their confirmation. "
+        "If the error's scope is \"app\", Spaces refused the tab because the window "
+        "is at its live-tab cap across chats; say that, and do not pretend the cap "
+        "is this chat's 10 tabs. "
         "Close tabs you opened when done. Do not expect a background SPA to finish "
         "loading while unfocused."
     ),
 )
 
 
+def _run_tool(ctx: chat_context.ChatContext, fn: Callable[_P, str], args: tuple[Any, ...], kwargs: dict[str, Any]) -> str:
+    """Run one tool against ``ctx`` only. Other chats keep their own lock and daemon."""
+    tokens = chat_context.enter(ctx)
+    try:
+        with ctx.lock, perf.timed_tool(fn.__name__) as rec:
+            try:
+                result = fn(*args, **kwargs)
+                rec.observe(result)
+                return result
+            except Exception as exc:
+                rec.fail()
+                in_app_cdp._reraise_public_harness_error(exc)
+    finally:
+        chat_context.leave(tokens)
+
+
 def _public_tool(fn: Callable[_P, str]) -> Callable[_P, str]:
     """Register-time wrapper that keeps CDP tokens out of tool failures.
 
@@ -89,23 +107,35 @@ def _public_tool(fn: Callable[_P, str]) -> Callable[_P, str]:
     endpoint it connects to, and FastMCP turns any raised exception into
     agent-visible ``ToolError`` text. Redacting inside individual helpers only
     covers the call sites someone remembered, so every tool goes through here.
+
+    The object FastMCP calls is ``_async_entry`` (see ``server``): the thread
+    id is read on the event loop, then context lookup and the tool body run
+    in a worker under that chat's lock. Context lookup can wait out a daemon
+    shutdown, so it must not run on the loop. Direct calls stay synchronous
+    so tests can invoke tools without an event loop. Two chats therefore run
+    at the same time; one chat's calls stay ordered.
     """
 
     @functools.wraps(fn)
     def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> str:
-        with _TOOL_LOCK, perf.timed_tool(fn.__name__) as rec:
-            try:
-                result = fn(*args, **kwargs)
-                rec.observe(result)
-                return result
-            except Exception as exc:
-                rec.fail()
-                in_app_cdp._reraise_public_harness_error(exc)
+        ctx = chat_context.context_for_call(chat_scope.current_thread_id())
+        return _run_tool(ctx, fn, args, kwargs)
+
+    @functools.wraps(fn)
+    async def async_entry(*args: _P.args, **kwargs: _P.kwargs) -> str:
+        thread_id = chat_scope.current_thread_id()
+
+        def run() -> str:
+            ctx = chat_context.context_for_call(thread_id)
+            return _run_tool(ctx, fn, args, kwargs)
+
+        return await anyio.to_thread.run_sync(run)
 
     # FastMCP copies fn.__doc__ as-is (not inspect.getdoc), so without this the
     # model sees the 4-space body indent from the source. @mcp.tool() wraps
     # this function, so the cleaned docstring is what list_tools returns.
     wrapper.__doc__ = inspect.getdoc(fn)
+    wrapper._async_entry = async_entry  # type: ignore[attr-defined]
     return wrapper
 
 

monkeybot-3.7.0/integrations/browser-mcp/src/browser_mcp/backend.py

@@ -0,0 +1,257 @@
+"""Browser backend binding: in-app CDP, local harness daemon, or AgentCore.
+
+In-app chats each own a :class:`browser_mcp.chat_context.ChatContext` (daemon,
+tab registry, lock). Local Chrome and AgentCore use
+:func:`browser_mcp.chat_context.shared`.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+from typing import Any
+
+from browser_mcp import agentcore, chat_context, chat_scope, dom_indexing, in_app_cdp, perf
+
+logger = logging.getLogger(__name__)
+
+_agentcore_admin: agentcore.AgentCoreAdmin | None = None
+
+
+def mark_unbound() -> None:
+    chat_context.active().bound_cdp = None
+
+
+def in_app_backend_active() -> bool:
+    """True when the live binding is Monkeyapp's in-app CDP bridge."""
+    ctx = chat_context.active()
+    return (
+        ctx.bh is not None
+        and ctx.bound_cdp not in (None, "agentcore")
+        and in_app_cdp._env_set_from_in_app_file
+    )
+
+
+def in_app_helpers() -> Any | None:
+    """Return in-app CDP helpers when the in-app backend is bound, else None."""
+    if not in_app_backend_active():
+        return None
+    ctx = chat_context.active()
+    assert ctx.bh is not None
+    helpers, _ = ctx.bh
+    return helpers
+
+
+def _ensure_active_context() -> chat_context.ChatContext:
+    """Bind the context for this call when the tool wrapper has not already."""
+    ctx = chat_context.context_for_call(chat_scope.current_thread_id())
+    if chat_context.current_context.get() is not ctx:
+        chat_context.current_context.set(ctx)
+        chat_context.current_daemon.set(ctx.daemon_name)
+    return ctx
+
+
+def teardown_bound_backend() -> None:
+    """Tear down whatever backend the active context is bound to, if any.
+
+    Clears ``bh`` before attempting the (possibly failing) teardown call, so a
+    raised exception here never leaves stale backend state behind for the next
+    ``browser_harness()`` call to mistakenly reuse. Dispatches on ``bound_cdp``
+    rather than introspecting the admin object, since the non-agentcore path
+    always re-imports (and stops) the real ``browser_harness.admin`` module.
+    """
+    ctx = chat_context.active()
+    if ctx.bh is None:
+        return
+    helpers, admin = ctx.bh
+    is_agentcore = ctx.bound_cdp == "agentcore"
+    with contextlib.suppress(Exception):
+        ctx.registry.detach_all(helpers)
+    ctx.bh = None
+    ctx.bound_cdp = None
+    dom_indexing.clear_registered_targets()
+    chat_scope.reset()
+    if is_agentcore:
+        admin.stop_session()
+        from browser_mcp import playwright_helpers
+
+        playwright_helpers.disconnect()
+        return
+    if ctx.isolated:
+        chat_context.drop(ctx)
+        return
+    from browser_harness import admin as bh_admin
+
+    bh_admin.restart_daemon()
+
+
+def _with_perf_helpers(bh: tuple[Any, Any]) -> tuple[Any, Any]:
+    helpers, admin = bh
+    return perf.wrap_helpers(helpers), admin
+
+
+def _announce_in_app(helpers: Any, ctx: chat_context.ChatContext) -> None:
+    """Tell an older app which chat this connection serves. Once per bind.
+
+    Current apps read ``chat=`` from the WebSocket URL, so a repeat announce
+    is only needed after the daemon reconnects. Playbook/login skip this by
+    not binding.
+    """
+    if not in_app_cdp._env_set_from_in_app_file or ctx.announced:
+        return
+    chat_scope.announce(helpers, ctx.thread_id)
+    ctx.announced = True
+
+
+def _reconnect_agentcore() -> tuple[str, dict[str, str]]:
+    """Force a fresh AgentCore session (stop + restart) and return new ws creds.
+
+    Registered with playwright_helpers as its reconnect hook: a stale/expired
+    AgentCore session (~15-30 min TTL) leaves the old ws connection dead, and
+    plain ensure_session() would just re-sign headers for the same (already
+    dead) session, so the old session is explicitly stopped first.
+    """
+    assert _agentcore_admin is not None
+    _agentcore_admin.stop_session()
+    return _agentcore_admin.ensure_session()
+
+
+def _agentcore_browser_harness(ctx: chat_context.ChatContext) -> tuple[Any, Any]:
+    """Bind the shared context to AgentCore (StartBrowserSession + Playwright)."""
+    global _agentcore_admin
+    from browser_mcp import playwright_helpers
+
+    if _agentcore_admin is None:
+        _agentcore_admin = agentcore.AgentCoreAdmin(agentcore.resolve_region())
+
+    ws_url, headers = _agentcore_admin.ensure_session()
+    playwright_helpers.connect(ws_url, headers)
+    playwright_helpers.set_reconnect_hook(_reconnect_agentcore)
+    ctx.bh = (playwright_helpers, _agentcore_admin)
+    ctx.bound_cdp = "agentcore"
+    return ctx.bh
+
+
+def _ensure_harness_daemon(
+    ctx: chat_context.ChatContext, endpoint: str | None
+) -> tuple[Any, Any]:
+    """Start or reuse this context's daemon without touching any other chat's."""
+    from browser_harness import admin, helpers
+
+    if ctx.bh is not None and endpoint == ctx.bound_cdp:
+        return ctx.bh
+
+    name = ctx.daemon_name
+    alive = admin.daemon_alive(name) if name else admin.daemon_alive()
+    if alive and ctx.bound_cdp != endpoint:
+        logger.info(
+            "browser-mcp: replacing harness daemon %s for CDP %s (was %s)",
+            name or "default",
+            in_app_cdp._redact_cdp_token(str(endpoint)) if endpoint else endpoint,
+            in_app_cdp._redact_cdp_token(str(ctx.bound_cdp)) if ctx.bound_cdp else ctx.bound_cdp,
+        )
+        if name:
+            admin.restart_daemon(name)
+        else:
+            admin.restart_daemon()
+        ctx.bh = None
+        ctx.announced = False
+
+    env: dict[str, str] | None = None
+    if ctx.isolated and endpoint:
+        env = {"BU_CDP_WS": endpoint} if endpoint.startswith(("ws://", "wss://")) else {"BU_CDP_URL": endpoint}
+    if name:
+        admin.ensure_daemon(name=name, env=env)
+    else:
+        admin.ensure_daemon()
+    ctx.bh = (helpers, admin)
+    ctx.bound_cdp = endpoint
+    return ctx.bh
+
+
+def browser_harness() -> tuple[Any, Any]:
+    """Lazy import + daemon bootstrap on first browser tool use.
+
+    When an explicit CDP URL is configured (env or Monkeyapp runtime file) and the
+    live daemon was bound to a different endpoint (or none — i.e. local Chrome),
+    bounce that daemon so tool calls drive the in-app panel instead.
+    BROWSER_BACKEND=agentcore (with no explicit CDP endpoint) dispatches to AWS
+    Bedrock AgentCore Browser instead.
+
+    In-app chats each get their own daemon. Bouncing one never restarts another.
+    """
+    chat_context.install_send_router()
+    in_app_cdp._apply_in_app_cdp_url()
+    ctx = _ensure_active_context()
+    endpoint = (
+        in_app_cdp.daemon_cdp_endpoint(ctx.thread_id) if ctx.isolated else in_app_cdp._apply_in_app_cdp_url()
+    )
+
+    if agentcore.agentcore_backend_requested():
+        chat_context.stop_all_isolated()
+        shared = chat_context.shared()
+        if chat_context.current_context.get() is not shared:
+            chat_context.current_context.set(shared)
+            chat_context.current_daemon.set(None)
+        if shared.bh is not None and shared.bound_cdp == "agentcore":
+            return _with_perf_helpers(shared.bh)
+        teardown_bound_backend()
+        return _with_perf_helpers(_agentcore_browser_harness(shared))
+
+    if ctx.bound_cdp == "agentcore":
+        teardown_bound_backend()
+        ctx = _ensure_active_context()
+
+    if ctx.bh is not None and endpoint == ctx.bound_cdp:
+        wrapped = _with_perf_helpers(ctx.bh)
+        _announce_in_app(wrapped[0], ctx)
+        return wrapped
+
+    bh = _ensure_harness_daemon(ctx, endpoint)
+    _announce_in_app(bh[0], ctx)
+    return _with_perf_helpers(bh)
+
+
+def stop_active_backend_best_effort() -> None:
+    """Stop the backend for the active chat.
+
+    ``browser_stop`` uses this so one chat does not tear down another chat's
+    daemon. Process exit uses :func:`stop_all_backends_best_effort`, which
+    also stops a leftover default daemon this process may never have bound.
+    """
+    from browser_mcp import tab_ops
+
+    ctx = chat_context.active()
+    if ctx.bound_cdp == "agentcore":
+        if ctx.bh is not None:
+            helpers, _ = ctx.bh
+            with contextlib.suppress(Exception):
+                tab_ops._close_agent_opened_tabs(helpers)
+        teardown_bound_backend()
+        return
+    if ctx.bh is not None:
+        helpers, _ = ctx.bh
+        with contextlib.suppress(Exception):
+            tab_ops._close_agent_opened_tabs(helpers)
+    ctx.bh = None
+    ctx.bound_cdp = None
+    ctx.announced = False
+    if ctx.isolated:
+        chat_context.drop(ctx)
+        return
+    chat_scope.reset()
+    from browser_harness import admin
+
+    admin.restart_daemon()
+
+
+def stop_all_backends_best_effort() -> None:
+    """Stop every per-chat daemon, then the shared/default one.
+
+    Shutdown must still restart the default daemon even when this process
+    never bound it: a leftover Browser Use Cloud daemon from an earlier
+    process keeps billing until something stops it.
+    """
+    chat_context.stop_all_isolated()
+    chat_context.deactivate()
+    stop_active_backend_best_effort()