Eve library

External Implementation Research: Bellona Remote Control

Guide

Revision 1

On this page

Research date: 2026-04-21

Scope: 180.C.02.10

This note records external implementation research for the Phase 180 Remote Creative Control Plane. It complements the repo audit notes, ADR-0001, and the compatibility matrix. It does not authorize implementation by itself; later tasks must still add protocol schemas, policy, approvals, audit, tests, and hardware evidence before privileged control paths are enabled.

Summary Decisions#

  • Use MCP Streamable HTTP and OAuth-style authorization patterns for future Bellona MCP access, but do not let MCP clients become command authorities.
  • Use Chrome DevTools Protocol only through localhost-bound host adapters with isolated browser profiles. Playwright remains the first test and browser automation harness.
  • Treat Browser Use and Computer Use systems as fallback/exploration patterns, not as the primary control plane for Blender, Unreal, or browser operations.
  • Require WebRTC signaling to be gateway-authorized. Same-LAN direct ICE paths are optimizations; TURN is required for reliable cloud/cross-NAT mode.
  • Treat macOS TCC permissions, signing, notarization, and helper separation as first-class host-runtime requirements rather than UI warnings.
  • Keep Blender and Unreal deep integrations inside local host adapters. Do not expose engine ports or editor scripting interfaces directly to the network.
  • Prefer outbound-only gateway/tunnel designs. Avoid direct remote desktop and direct RDP/VNC-style exposure for Bellona production control.

MCP Transports and Authorization#

Sources reviewed:

Findings:

  • MCP's HTTP authorization guidance is built around OAuth 2.1 style flows for public clients, including PKCE, secure token storage, token refresh, metadata discovery, and dynamic client registration where available.
  • MCP servers must validate access tokens as tokens intended for that server, not as general-purpose bearer strings. Token passthrough creates a confused deputy risk when MCP servers proxy downstream APIs.
  • Streamable HTTP is the right production-oriented transport family for remote tools. Stdio is useful for local development and testing but does not solve cloud routing, identity, or audit by itself.
  • The OpenAI developer docs MCP server is explicitly read-only and documentation-scoped. That is a useful precedent: MCP servers can expose a constrained tool/resource surface without becoming a privileged control plane.

Bellona stance:

  • Build libs/bellona/mcp-gateway as a client of the Bellona Remote Gateway, not as an execution authority.
  • Prefer Streamable HTTP for future cloud/LAN MCP access and stdio only for local developer fixtures.
  • Bind MCP tool scopes to Bellona protocol scopes. A command like remote.command.dispatch must carry actor, session, device, command, approval, policy, and audit metadata.
  • Reject token passthrough. Gateway-issued or identity-provider-issued tokens must be audience-bound to the Bellona gateway/MCP resource.

Implementation gates:

  • Add protocol schemas for actor identity, session scope, device scope, command risk, approval state, and audit correlation before any MCP command dispatch exists.
  • Add tests for missing token, wrong audience, expired token, replayed token, insufficient scope, denied policy, and approval-required command attempts.

Chrome DevTools Protocol#

Sources reviewed:

Findings:

  • CDP can instrument, inspect, debug, profile, mutate, and capture Chromium, Chrome, and other Blink-based browsers. It is powerful enough to expose page contents, network state, storage, cookies, screenshots, and JavaScript execution.
  • The CDP tip-of-tree protocol changes frequently and has no backwards compatibility guarantee. Runtime capability/version probing is required.
  • Chrome exposes protocol metadata through local HTTP endpoints when launched with remote debugging.
  • Chrome 136 and later ignore remote debugging switches against the default Chrome data directory; remote debugging now requires a non-default --user-data-dir. Google recommends Chrome for Testing for automation scenarios.
  • Chrome extension access through chrome.debugger requires the debugger permission and is still a high-risk browser-control surface.

Bellona stance:

  • Use CDP only through host-local browser adapters. CDP ports must bind to 127.0.0.1/localhost and must never be exposed directly to LAN or cloud.
  • Use isolated user-data-dir profiles for automation. Real user profiles, credential stores, cookies, and default profile CDP are blocked until the threat model, policy, redaction, and approval work exists.
  • Record browser version, protocol version, profile type, profile path grant, and CDP endpoint provenance in adapter capabilities and audit entries.

Implementation gates:

  • Add adapter tests for CDP version discovery, page listing, screenshot/query, navigation, timeout, cancel, and crash/restart behavior.
  • Add explicit policy gates for storage/cookie inspection, downloads/uploads, JavaScript evaluation, cross-origin data extraction, and authenticated flows.

Playwright#

Sources reviewed:

Findings:

  • Playwright is the strongest fit for deterministic browser tests, Control Room QA, and isolated browser automation because it provides repeatable browser lifecycle, contexts, tracing, screenshots, and multi-browser test support.
  • connectOverCDP is Chromium-only and lower fidelity than Playwright's own protocol connection. It is useful for attaching to a browser already launched by the host, but not as the default path for new automated tests.
  • Playwright MCP is useful as a reference for exposing browser actions to agents, but Bellona should not route privileged browser commands through a generic browser MCP server that bypasses gateway policy and audit.

Bellona stance:

  • Use Playwright for automated tests and for isolated browser automation when the host owns the browser lifecycle.
  • Use CDP attach only when controlling an already-running isolated browser instance created by the host runtime.
  • Keep browser action schemas in libs/bellona/remote-protocol; Playwright calls are implementation details of the browser adapter.

Implementation gates:

  • Add Playwright coverage for Control Room once that app exists.
  • Add browser adapter fixtures for isolated profile creation, navigation, snapshot, screenshot, download/upload path grants, and teardown.

Browser Use#

Sources reviewed:

Findings:

  • Browser Use is an agent-oriented browser automation library. Its Actor layer exposes Playwright-like operations but is built on direct CDP control.
  • The project is useful for comparing agent ergonomics, page-state extraction, natural-language element lookup, retry loops, and remote browser patterns.
  • Browser Use Cloud and profile-sync features are high-risk for Bellona because profile movement and remote browser sessions can cross credential and data boundaries.

Bellona stance:

  • Treat Browser Use as external inspiration for browser-agent UX and action vocabulary, not as the canonical Bellona browser adapter.
  • Do not sync real user profiles to remote browser providers for Bellona remote-control workflows.
  • Reuse ideas such as session manager, page abstraction, DOM/element state, and task retries only after they are expressed in Bellona protocol schemas and policy gates.

Implementation gates:

  • Add browser capability schemas that distinguish isolated profile, persistent-but-empty profile, real user profile, remote browser provider, and profile sync.
  • Block remote provider/profile sync unless an explicit future ADR accepts that data boundary.

Codex and Claude Computer Use#

Sources reviewed:

Findings:

  • OpenAI's Computer Use guidance emphasizes UI interaction through a computer tool and recommends isolation, allow lists, and human review for sensitive, destructive, authenticated, purchase, or hard-to-reverse actions.
  • OpenAI Computer Use is currently documented around the computer-use-preview model and computer_use_preview tool in the Responses API. The docs describe it as beta and call out prompt-injection, sensitive domain, and human-in-the-loop safety requirements.
  • Codex CLI is a local coding agent and should be treated as an operator/agent client, not as a remote-control protocol for Bellona devices.
  • Anthropic's Computer Use architecture is built around an agent loop: the model requests tool actions, the application executes those actions in a sandboxed or virtualized environment, captures results, and returns them to the model.
  • Anthropic's reference environment is containerized/Xvfb-oriented. Bellona's controlled MacBook host is different: it needs macOS native TCC, screen capture, Accessibility, input, app focus, and signing behavior.

Bellona stance:

  • Support Codex/Claude/other agents through MCP or Gateway client APIs. They submit Bellona protocol commands; they do not get direct desktop authority.
  • Reuse Computer Use fallback primitives for cases without reliable deep APIs, but only under policy, approval, audit, evidence capture, and emergency stop.
  • Prefer API/deep adapters over pixel/desktop fallback. Computer Use should be last resort, not the control plane's first execution path.

Implementation gates:

  • Add desktop fallback protocol schemas and risk classes before input control exists.
  • Add allow/deny domain and app policies, human approval gates for sensitive actions, screenshot/evidence redaction, and explicit operator takeover.

WebRTC and TURN#

Sources reviewed:

Findings:

  • WebRTC connectivity depends on ICE candidate gathering and selection. Host, server-reflexive, peer-reflexive, and relay candidates have different reliability/performance behavior.
  • TURN relay candidates are required when direct connectivity fails. For cloud gateway and cross-NAT operation, TURN is a production requirement rather than a nice-to-have.
  • coturn is the most established open-source TURN/STUN server candidate and supports standard TURN/STUN specs, TLS/DTLS options, user databases, REST credential patterns, and metrics integrations.
  • WebRTC media should not be coupled to command delivery. Command/control must continue to work if media is degraded or unavailable.

Bellona stance:

  • Put WebRTC signaling metadata in libs/bellona/remote-protocol.
  • Gateway authorizes sessions and signaling; host and Control Room exchange offers, answers, and ICE candidates only within an authorized session.
  • Same-LAN direct media is an optimization. Cloud mode requires TURN relay compatibility and degraded-state UI.

Implementation gates:

  • Add fake signaling tests before real media.
  • Add network impairment tests for reconnect, ICE restart, bandwidth drop, TURN-only relay, and teardown.
  • Require two-Mac and cross-network hardware evidence before checking live stream implementation tasks.

macOS TCC, Capture, Accessibility, and Signing#

Sources reviewed:

Findings:

  • macOS requires explicit user authorization for protected capture resources. Missing usage-description keys can terminate apps when requesting protected resources.
  • Screen capture, microphone/camera capture, Accessibility, input control, and file/folder grants are separate permission surfaces with different prompts and reset/debug flows.
  • Accessibility trust must be requested and observed as an operator-visible host state. It cannot be assumed silently.
  • Notarization and hardened runtime requirements affect helper design, entitlements, updates, and distribution.

Bellona stance:

  • Build libs/bellona/mac-host-runtime as a native permission, helper, diagnostics, capture, input, signing, and update boundary.
  • Remote Host must expose permission state and degraded capability reports to the gateway; Control Room must render missing-permission states before any fallback action is attempted.
  • Do not ship unsigned or ad hoc privileged helpers as a production path.

Implementation gates:

  • Add host diagnostics command returning permission status placeholders before real fallback controls.
  • Add manual evidence for screen capture, Accessibility, input, multi-display, app focus, permission denial, permission reset, and signed/notarized startup.

Blender Addon APIs#

Sources reviewed:

Findings:

  • Blender add-ons are Python modules with bl_info, register(), and unregister() lifecycle hooks. This aligns with the audited Bellona addon.
  • Operators, handlers, timers, and panels are standard extension mechanisms.
  • Blender Python execution runs inside Blender's embedded Python environment. External Python packages must be handled carefully and cannot be assumed from the system Python environment.
  • Blender's Python threading model is risky; remote command execution should be marshaled back to Blender-safe handlers/timers and avoid long blocking work on UI-critical paths.

Bellona stance:

  • Use the existing Bellona addon startup, timer, diagnostics, and handler patterns as the first Blender remote adapter foundation.
  • Keep addon transport localhost-only. The Remote Host talks to Blender locally and reports audited results through the gateway.
  • Keep arbitrary Python disabled until a future policy/approval/audit design explicitly permits a narrowly-scoped execution mode.

Implementation gates:

  • Add adapter tests for command allow list, payload validation, timeouts, cancellation, main-thread scheduling, error reporting, and evidence capture.
  • Add Blender hardware evidence for addon installation, auto-start behavior, safe scene read, safe primitive mutation, and crash/restart handling.

Unreal Editor Plugin and Remote APIs#

Sources reviewed:

Findings:

  • Unreal provides Python editor scripting and Remote Control HTTP/WebSocket APIs, but these surfaces are editor-powerful and must be treated as privileged local controls.
  • Plugin/module compatibility is engine-version-sensitive. Editor modules and runtime modules have different constraints and packaging implications.
  • Repo docs currently support Unreal 5.0-5.3, while upstream documentation has moved to newer engine releases. The first implementation should target the repo-proven 5.3 path before expanding.

Bellona stance:

  • Use Unreal 5.3 as the first adapter target and record 5.4-5.6 as candidates pending plugin/API tests.
  • Keep Unreal Remote Control and Python scripting reachable only through the host-local adapter boundary.
  • Keep console commands, arbitrary Python/editor scripting, destructive actor operations, and project mutation blocked until protocol risk classes, policy, approvals, undo/evidence, and audit exist.

Implementation gates:

  • Add fake Unreal adapter tests before real editor integration.
  • Add hardware evidence for version discovery, project open, read-only world query, safe actor spawn in a fixture level, timeout/cancel, screenshot, and editor crash/restart.

Remote Desktop Security Patterns#

Sources reviewed:

Findings:

  • Remote access from external networks carries higher risk than internal-only access and needs explicit policy, identity, authentication, hardening, monitoring, and contingency planning.
  • RDP-style direct remote desktop access is a common initial access and lateral movement path. Guidance favors VPN/zero-trust access, MFA, role-based access, and restricted exposure when remote desktop is unavoidable.
  • Bellona's vision is not generic remote desktop. Deep adapters and protocol commands offer a safer, more auditable route than exposing a full desktop stream/control interface.

Bellona stance:

  • Use remote desktop only as a fallback mental model for risk controls, not as the primary implementation.
  • Prefer command-specific protocol actions, least privilege, explicit approvals, durable audit, redaction, emergency stop, and takeover over broad desktop sessions.
  • Never expose VNC/RDP/screen-control ports directly as the Bellona remote control surface.

Implementation gates:

  • Add threat-model coverage for compromised gateway, host, agent, browser page, local network attacker, replay, prompt injection, and credential exposure before desktop fallback implementation.

Cloud Tunnel Options#

Sources reviewed:

Findings:

  • Tailscale uses WireGuard encryption, DERP relay negotiation/fallback, and NAT traversal. It is useful for operator-managed same-LAN or trusted tailnet deployments, but it introduces tailnet identity/admin dependencies.
  • Tailscale Funnel exposes selected services publicly over constrained TLS ports with policy-file gating and bandwidth limits. That is useful for demos and webhooks, but it is not a general production control plane for arbitrary Bellona remote host operations.
  • WireGuard is a strong primitive for private network paths, but raw WireGuard alone does not provide Bellona sessions, command routing, approvals, audit, MCP access, or Control Room state.
  • Cloudflare Tunnel provides outbound-only cloudflared connections to Cloudflare and can protect private apps/remote desktop through Zero Trust policies. It is a viable cloud-adjacent access option but still does not replace Bellona's protocol authority.
  • ngrok provides quick public tunnels and authentication policy examples. It is suitable for development demos but should not become the production trust boundary for privileged host control.

Bellona stance:

  • Build Bellona Remote Gateway as the primary routing and authority layer. Use tunnels/VPNs as optional network underlays or deployment aids, not protocol replacements.
  • Require Remote Host outbound WSS to the gateway as the default path. Optional Tailscale/WireGuard/Cloudflare/ngrok modes must still preserve gateway identity, policy, approval, and audit.
  • Treat any public tunnel as production-hostile unless it is paired with gateway auth, least privilege, audit, and environment-specific policy.

Implementation gates:

  • Add compatibility tests for explicit gateway URL, host reconnect, tunnel outage, gateway restart, TURN relay, and degraded/offline state.
  • Add deployment notes later for same-LAN, Tailscale tailnet, Cloudflare Tunnel, and cloud WSS modes without changing the canonical gateway/host architecture.

Open Research Questions for Later Tasks#

  • Which OAuth/OIDC provider should issue Bellona gateway/MCP tokens for local development, LAN demos, and cloud deployments?
  • Should Bellona ship its own TURN deployment first, use a managed TURN provider, or support both through configuration?
  • Which macOS host pieces require Swift/Objective-C helpers instead of TypeScript/Node bindings?
  • Which Blender 4.5 and Unreal 5.6 API changes are worth supporting in the first adapter wave versus after the 5.3/4.0 baselines pass?
  • What redaction rules should apply to screenshots, browser DOM text, clipboard contents, file paths, credentials, and engine asset metadata?
  • Which tunnel modes should be allowed in production versus development-only?