# External Implementation Research: Bellona Remote Control

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-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:

- 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.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:

- Playwright browser support: <https://playwright.dev/docs/browsers>
- Playwright `connectOverCDP` API:
  <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.
- `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:

- 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-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:

- 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-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:

- 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()`, 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:

- 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 `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?
