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:
- Model Context Protocol authorization specification: https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization
- Model Context Protocol security best practices: https://modelcontextprotocol.io/specification/2025-06-18/basic/security_best_practices
- OpenAI Docs MCP guidance: https://developers.openai.com/learn/docs-mcp
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-gatewayas 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.dispatchmust 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:
- Chrome DevTools Protocol: https://chromedevtools.github.io/devtools-protocol/
- Chrome remote debugging security change: https://developer.chrome.com/blog/remote-debugging-port
- Chrome debugger extension API: https://developer.chrome.com/docs/extensions/reference/api/debugger
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.debuggerrequires thedebuggerpermission 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:
- Playwright browser support: https://playwright.dev/docs/browsers
- Playwright
connectOverCDPAPI: https://playwright.dev/docs/api/class-browsertype - Playwright MCP browser automation: https://playwright.dev/agents/playwright-mcp-browser-automation
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.
connectOverCDPis 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:
- Browser Use open-source docs: https://docs.browser-use.com/
- Browser Use Actor basics: https://docs.browser-use.com/open-source/legacy/actor/basics
- Browser Use GitHub project: https://github.com/browser-use/browser-use
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:
- OpenAI Computer Use guide: https://platform.openai.com/docs/guides/tools-computer-use
- OpenAI Codex CLI repository: https://github.com/openai/codex
- Anthropic Computer Use tool documentation: https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool
- Anthropic computer-use announcement: https://www.anthropic.com/news/developing-computer-use/
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-previewmodel andcomputer_use_previewtool 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:
- MDN WebRTC connectivity: https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Connectivity
- MDN WebRTC protocol overview: https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API/Protocols
- coturn TURN server: https://github.com/coturn/coturn
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:
- Apple media capture authorization: https://developer.apple.com/documentation/bundleresources/requesting-authorization-for-media-capture-on-macos
- Apple ScreenCaptureKit: https://developer.apple.com/documentation/screencapturekit/capturing_screen_content_in_macos
- Apple Accessibility trust API: https://developer.apple.com/documentation/applicationservices/1459186-axisprocesstrustedwithoptions
- Apple notarization/hardened runtime guidance: https://developer.apple.com/documentation/security/resolving-common-notarization-issues
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-runtimeas 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:
- Blender add-on tutorial: https://docs.blender.org/manual/en/latest/advanced/scripting/addon_tutorial.html
- Blender Python API: https://docs.blender.org/api/current/
- Blender application timers: https://docs.blender.org/api/current/bpy.app.timers.html
- Blender application handlers: https://docs.blender.org/api/current/bpy.app.handlers.html
- Blender Python threading gotchas: https://docs.blender.org/api/current/info_gotchas_threading.html
Findings:
- Blender add-ons are Python modules with
bl_info,register(), andunregister()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:
- Unreal Python editor scripting: https://dev.epicgames.com/documentation/en-us/unreal-engine/scripting-the-unreal-editor-using-python
- Unreal Remote Control API HTTP reference: https://dev.epicgames.com/documentation/en-us/unreal-engine/remote-control-api-http-reference-for-unreal-engine
- Unreal Remote Control API WebSocket reference: https://dev.epicgames.com/documentation/en-us/unreal-engine/remote-control-api-websocket-reference-for-unreal-engine
- Unreal plugins documentation: https://dev.epicgames.com/documentation/en-us/unreal-engine/plugins-in-unreal-engine
- Unreal Engine 5.6 release notes: https://dev.epicgames.com/documentation/unreal-engine/unreal-engine-5-6-release-notes
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:
- NIST SP 800-46 remote access security: https://csrc.nist.gov/pubs/sp/800/46/r1/final
- CISA remote desktop restriction guidance: https://www.cisa.gov/eviction-strategies-tool/info-countermeasures/CM0042
- CISA/NSA/FBI/MS-ISAC remote access software guide: https://www.cisa.gov/sites/default/files/2023-06/guide_to_securing_remote_access_software.pdf
- Cloudflare RDP with Zero Trust: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/use-cases/rdp/rdp-device-client/
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:
- Tailscale connection types: https://tailscale.com/docs/reference/connection-types
- Tailscale Funnel: https://tailscale.com/docs/features/tailscale-funnel
- WireGuard quick start: https://www.wireguard.com/quickstart/
- Cloudflare Tunnel: https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/
- ngrok Agent CLI quickstart: https://ngrok.mintlify.dev/docs/getting-started
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
cloudflaredconnections 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?