Phase: 180.C.20.06 Status: Decision — extension mode IS approved for a minimal MV3 extension. Direct CDP remains the verified default for driving the browser; the extension exists only to close three specific value gaps CDP cannot cleanly fill (a tamper-resistant visible-automation indicator, a native-ish consent/approval popup, and a per-origin profile-grant surface). The extension is implemented in 180.C.20.07 and adversarially tested in 180.C.20.08. Scope: Whether a browser extension earns its place alongside the existing direct-CDP host browser surface for overlays, profile grants, page annotations, and consent UI — and, if so, with what trust posture.
This evaluation is anchored to what the Bellona remote-control surface already
ships: the deterministic CDP/Playwright host browser adapter
(apps/bellona/remote-host/src/browser-adapter.ts), the browser-agent provider
plane and 180.C.20.04 policy gate
(libs/bellona/remote-protocol/src/browser-agent-provider.ts), and the
profile-isolation policy (browser-profile-isolation.md). The question is not
"extension vs. CDP" as a backend (CDP wins that — see
browser-use-vs-direct-cdp-evaluation.md); it is "is there a UX/trust surface
only an extension can provide, on top of CDP."
Honesty note (what is and isn't built). The MV3 extension authored in 180.C.20.07 cannot be loaded in this CI environment — there is no Chrome profile or extension-host harness on the box. So the extension's security DECISIONS are implemented as pure, unit-tested functions (
apps/bellona/remote-extension/src/), and the Chrome-runtime wiring (background.ts,content-script.ts) is a thin shell over them. Where this doc says "the extension does X," the logic of X is the cited pure function with a test; the Chrome glue is not asserted by an automated browser load. This is the same dependency-boundary discipline the Browser Use seam uses (we don't fabricate a runtime we can't exercise).
1. The four candidate value areas, judged against CDP#
For each area: what CDP can do today, what an extension adds, and whether the delta is concrete (a capability CDP genuinely lacks) or cosmetic (CDP can do it, the extension is just nicer).
1.1 Overlays / page annotations#
| Direct CDP | MV3 extension | |
|---|---|---|
| Inject a banner/annotation | Yes — Runtime.evaluate / Playwright addScriptTag can inject DOM |
Yes — content script injects DOM |
| Page can remove it | Yes — the injected node lives in the page's own DOM; page JS can node.remove(), restyle it, or a SPA re-render can wipe it, and CDP has no reliable "keep it there" primitive |
No (resistant) — the content script runs in an ISOLATED world, mounts the banner in a closed Shadow DOM (page CSS/JS cannot read or restyle it), and a MutationObserver re-mounts it the instant the page removes or hides it; a look-alike node planted under the same id fails the integrity stamp |
| Survives navigation | Re-inject after every navigation (host bookkeeping) | Content script auto-runs at document_start on every allow-listed navigation |
Verdict: CONCRETE for the visible-automation indicator; cosmetic for generic
annotations. A decorative annotation is fine over CDP. But a banner whose
entire purpose is to truthfully tell a human "automation is driving this tab
right now" is a safety control, and a safety control the page can silently
delete is not a control. CDP cannot make the indicator tamper-resistant; an
isolated-world content script with a re-mounting MutationObserver can. This is
gap #1.
1.2 Consent UI / approval popup#
| Direct CDP | MV3 extension | |
|---|---|---|
| Where consent is collected today | In the Control Room (a first-party web app) — the operator approves an in-app dialog; the approval is a plan-bound token the 180.C.20.04 gate checks | Same Control Room path still works |
| In-page / browser-chrome consent | CDP can only draw into the page (spoofable: a page can mimic the dialog); it cannot put UI in the browser chrome | The extension action popup is browser-chrome UI the page cannot draw over or spoof; an externally_connectable-scoped channel lets the gateway drive an approval prompt that is visibly not page content |
| Trust origin of the prompt | The page (or an injected overlay) — weak | The extension (browser chrome) — strong |
Verdict: CONCRETE but NARROW. The Control Room already collects consent and the 180.C.20.04 gate already enforces it, so the extension does not replace the approval system. What it adds is a consent/approval surface that lives in browser chrome, which a hostile page cannot spoof or obscure — useful specifically when the operator is watching the target tab rather than the Control Room. This is gap #2 (a refinement, not a new authority).
1.3 Profile grants (per-origin)#
| Direct CDP | MV3 extension | |
|---|---|---|
| Profile model today | Bellona-managed isolated profiles only; personal-profile access is a privileged, human-consented, restricted-origin, visible-stream session (browser-profile-isolation.md) |
Same model; extension does not touch the personal profile wholesale |
| Per-origin scoping | CDP grants are per-session/per-launch; the origin allow-list is enforced by the host, not surfaced to the human as a standing per-origin grant | The extension's host_permissions ARE an explicit per-origin allow-list the human sees at install/grant time, and the per-session capability grant binds clipboard/upload/form to specific origins |
| Visibility of "what is granted where" | Buried in host config | A first-class, per-origin surface (the manifest + the grant view) |
Verdict: CONCRETE for surfacing/scoping grants per origin. CDP can confine
a session to origins, but it has no native notion of "the human granted
automation permission on these specific origins and nothing else, and can
see and revoke that." An extension's host_permissions model is exactly a
per-origin grant surface. This is gap #3.
1.4 Net: three concrete gaps, all UX/trust (not capability)#
None of the gaps is "the extension can drive the browser better" — CDP drives better (deterministic, on-box, auditable). All three are trust-surface gaps: a tamper-resistant indicator, a spoof-proof consent surface, and a per-origin grant surface. That is precisely the value an extension adds that CDP structurally cannot.
2. The cost / risk side (why "minimal" and why policy-gated)#
An extension is not free. The same isolated-world power that makes the indicator tamper-resistant also means the content script sees and can act on page content — it is, like Browser Use, a third-party-ish surface from the trust model's point of view. The risks, and how the 180.C.20.07 design contains them:
| Risk | Containment (180.C.20.07) |
|---|---|
Over-broad host access (<all_urls>) |
Forbidden by construction. host_permissions and content_scripts.matches are an explicit operator allow-list; compileExtensionOriginAllowList / assertManifestDomainScoped reject <all_urls>, *://*/*, http(s)://*/* fail-loud. |
| A malicious iframe forging commands | verifyExtensionMessageOrigin rejects any sender whose origin is not the trusted host (and any sub-frame under requireTopFrame) before the payload is read; page-world traffic is additionally bound to a per-session token. |
| A page baiting clipboard/upload/form | evaluateClipboardAccess / evaluateFileUpload / evaluateFormSubmission are closed-by-default: refused unless the capability was explicitly granted and a single-use approval token + allow-listed origin match — the same discipline as the 180.C.20.04 gate and the 180.C.19.04/.06 upload/credential guards. |
| Extension impersonation / foreign extension | verifyExtensionMessageSender trusts only THIS extension id or an allow-listed external host origin; externally_connectable names one gateway origin, never a wildcard. |
| Stale authority after disable/uninstall | runExtensionTeardown revokes the session token, drops every capability grant, and tears down the indicator; post-teardown authorize() returns null so no message authenticates. |
| Excess permissions | permissions is the justified minimal set (scripting, activeTab, storage); clipboardRead/Write are optional (runtime-requested, gated), never install-time. |
Why "minimal": every capability beyond the three gaps is attack surface without a justifying value gap. So the approved extension does the three things and nothing else — it is not a general automation backend (that is CDP) and not an agent (that is Browser Use).
3. Decision#
-
Approve a minimal MV3 extension as an optional trust-surface layer on top of direct CDP. It is justified by three concrete gaps CDP cannot cleanly fill:
- a tamper-resistant, page-visible automation indicator (the page cannot remove or spoof it — isolated-world + closed Shadow DOM + re-mounting observer + integrity stamp),
- a native-ish consent/approval popup in browser chrome (spoof-proof, unlike an in-page overlay), refining — not replacing — the Control Room + 180.C.20.04 approval system, and
- a per-origin profile-grant surface (
host_permissionsas an explicit, human-visible, revocable per-origin allow-list).
-
Direct CDP stays the default and the only automation backend. The extension does not drive tasks, does not receive credentials, and is never required for the deterministic browser MVP (180.C.20.10). It is purely additive UX/trust.
-
The extension is a third-party-ish surface and is policy-gated like one. Domain-scoped (
<all_urls>forbidden), extension-origin authenticated (handshake + per-session token, malicious-iframe-rejecting), and its sensitive actions (clipboard/upload/form) are closed-by-default behind the same explicit-approval discipline as the rest of Bellona. Disable/uninstall revokes everything. -
No fabricated runtime. The extension cannot be loaded in CI, so its security logic is implemented and tested as pure functions; the Chrome glue is a thin shell. We assert the logic, not a browser load we cannot perform.
What this unblocks / requires#
- 180.C.20.07 (implement the minimal manifest, domain-scoped permissions, extension-origin authentication, visible automation indicator) — required by this approval.
- 180.C.20.08 (adversarial extension tests) — required.
- 180.C.20.09 (when each of CDP / Browser Use / extension / desktop is allowed) — the decision matrix that places this surface relative to the others.
4. Evidence pointers#
- Extension security primitives (pure, unit-tested) and Chrome wiring:
apps/bellona/remote-extension/src/(origin-policy.ts,extension-auth.ts,action-guards.ts,automation-indicator.ts,session-lifecycle.ts,manifest-policy.ts,background.ts,content-script.ts,manifest.json). - The MV3 manifest proving domain-scoping (NOT
<all_urls>):apps/bellona/remote-extension/src/manifest.json(validated bymanifest-policy.test.ts). - The trust model this extension mirrors (third-party → policy-gated,
origin-authenticated, no credentials without approval):
libs/bellona/remote-protocol/src/browser-agent-provider.tsandbrowser-use-vs-direct-cdp-evaluation.md§6. - The profile-isolation policy the per-origin grant surface extends:
browser-profile-isolation.md. - Where each surface is allowed:
remote-control-mode-allowance-matrix.md(180.C.20.09).