From baed5dd45feb9f7cd5bc590c48ff75a2092bd31a Mon Sep 17 00:00:00 2001 From: tiisetso Date: Mon, 19 Oct 2026 18:50:07 +0200 Subject: [PATCH] fix(browser): keep browser defaults below user permissions The desktop injected 19 browser permission rules through OPENCODE_CONFIG_CONTENT, which merges after the user's global config. Those rules replaced any ask or deny the user had set, including a wildcard deny. Move them into the cm-browser config hook, which already places its lifecycle defaults before user rules, so the user's last matching rule wins. The values are unchanged: browser_open_history stays ask and every other browser tool is allow. The router also rejected desktop_set_panel whenever an authority object was present. The bridge passes ordinary task authority on every request, so ordinary sessions could never switch panels. Reject only delegated authority, which carries a lease token. The panel handler still checks native task ownership and agent access. --- packages/cm-browser/src/plugin.ts | 37 +++++++++++++++-- packages/cm-browser/test/plugin.test.ts | 40 +++++++++++-------- .../src/main/browser/delegation.test.ts | 30 +++++++++++++- packages/desktop/src/main/browser/router.ts | 4 +- .../main/wpp-bridge/proxy/providerConfig.mjs | 25 +----------- .../wpp-bridge/proxy/providerConfig.test.ts | 32 +++------------ 6 files changed, 97 insertions(+), 71 deletions(-) diff --git a/packages/cm-browser/src/plugin.ts b/packages/cm-browser/src/plugin.ts index f66d6a2a85..ef617c97e2 100644 --- a/packages/cm-browser/src/plugin.ts +++ b/packages/cm-browser/src/plugin.ts @@ -5,14 +5,43 @@ import { browserDelegation } from "./delegation" const port = ipcPort() +// OpenCode defaults for every bundled browser tool. Lifecycle tools use standing task authority and +// page tools rely on main's tab grant, so only opening a history result keeps an OpenCode prompt. +// These live here, not in the desktop's injected config, which merges after the user's global +// config and would replace their rules. +const PERMISSION_DEFAULTS = { + browser_create_tab: "allow", + browser_select_tab: "allow", + browser_close_tab: "allow", + desktop_set_panel: "allow", + browser_read_state: "allow", + browser_search_history: "allow", + browser_open_history: "ask", + browser_navigate: "allow", + browser_click: "allow", + browser_hover: "allow", + browser_drag: "allow", + browser_select_option: "allow", + browser_screenshot: "allow", + browser_visual_action: "allow", + browser_observe_console: "allow", + browser_observe_network: "allow", + browser_list_site_tools: "allow", + browser_execute_site_tool: "allow", + browser_fill: "allow", + browser_press_key: "allow", + browser_scroll: "allow", + browser_wait_for_element: "allow", + browser_wait_for_navigation: "allow", +} + export const server: Plugin = async () => ({ async config(config) { - // Defaults precede user rules, including wildcard rules and explicit deny/ask. + // Defaults precede user rules, including wildcard rules and explicit deny/ask. OpenCode applies + // the last matching rule, so any rule the user sets wins. if (typeof config.permission === "string") return const defaults = Object.fromEntries( - ["browser_create_tab", "browser_select_tab", "browser_close_tab", "desktop_set_panel"] - .filter((key) => !Object.hasOwn(config.permission ?? {}, key)) - .map((key) => [key, "allow"]), + Object.entries(PERMISSION_DEFAULTS).filter(([key]) => !Object.hasOwn(config.permission ?? {}, key)), ) config.permission = { ...defaults, ...config.permission } }, diff --git a/packages/cm-browser/test/plugin.test.ts b/packages/cm-browser/test/plugin.test.ts index 4ca7cd40fd..0b30a70fc7 100644 --- a/packages/cm-browser/test/plugin.test.ts +++ b/packages/cm-browser/test/plugin.test.ts @@ -2,26 +2,34 @@ import { expect, test } from "bun:test" import type { Plugin } from "@opencode-ai/plugin" import { server } from "../src/plugin" -test("lifecycle defaults precede user wildcard and exact rules without overriding policy", async () => { +test("browser defaults precede user wildcard and exact rules without overriding policy", async () => { const hooks = await server({} as Parameters[0]) - const user = { "*": "ask", browser_create_tab: "deny", browser_select_tab: "ask" } + const user = { + "*": "ask", + browser_create_tab: "deny", + browser_select_tab: "ask", + browser_fill: "ask", + browser_execute_site_tool: "deny", + } const config = { permission: user } as Parameters>[0] await hooks.config!(config) - expect(config.permission).toEqual({ browser_close_tab: "allow", desktop_set_panel: "allow", ...user }) - expect(Object.keys(config.permission!)).toEqual([ - "browser_close_tab", - "desktop_set_panel", - "*", - "browser_create_tab", - "browser_select_tab", - ]) - const fresh = {} - await hooks.config!(fresh) - expect(fresh).toEqual({ - permission: { - browser_create_tab: "allow", browser_select_tab: "allow", browser_close_tab: "allow", desktop_set_panel: "allow", - }, + // OpenCode applies the last matching rule, so every default must precede the user's rules. + expect(Object.keys(config.permission!).slice(-5)).toEqual(Object.keys(user)) + expect(Object.keys(config.permission!)).toHaveLength(Object.keys(hooks.tool!).length + 1) + expect(config.permission).toMatchObject({ + browser_close_tab: "allow", + desktop_set_panel: "allow", + browser_read_state: "allow", + browser_open_history: "ask", + ...user, }) + const fresh = {} as Parameters>[0] + await hooks.config!(fresh) + // Every bundled browser tool has a default. Only opening a history result keeps an OpenCode prompt. + expect(Object.keys(fresh.permission!).sort()).toEqual(Object.keys(hooks.tool!).sort()) + expect(Object.entries(fresh.permission!).filter(([, action]) => action !== "allow")).toEqual([ + ["browser_open_history", "ask"], + ]) for (const permission of ["ask", "deny", "allow"] as const) { const policy = { permission } // The legacy SDK type omits string and arbitrary-tool policies supported at runtime. diff --git a/packages/desktop/src/main/browser/delegation.test.ts b/packages/desktop/src/main/browser/delegation.test.ts index 1d3c9c298d..08c3b5784b 100644 --- a/packages/desktop/src/main/browser/delegation.test.ts +++ b/packages/desktop/src/main/browser/delegation.test.ts @@ -1,7 +1,7 @@ import { expect, test } from "bun:test" import { EventEmitter } from "node:events" import { randomUUID } from "node:crypto" -import type { BrowserIpcResult, Request, WriteRequest } from "@cookiemonster/cm-browser/protocol" +import { success, type BrowserIpcResult, type Request, type WriteRequest } from "@cookiemonster/cm-browser/protocol" import { attachBrowserBridge } from "./bridge" import { resolveBrowserOwnerScope, setBrowserOwnerScopeResolver } from "./session-resolver" import { createBrowserDelegations } from "./delegation" @@ -14,6 +14,7 @@ import { invalidateBrowserDocument, setBrowserTabHandler, setBrowserHistoryHandler, + setBrowserPanelHandler, type BrowserRegistration, } from "./registry" import type { BrowserSession, BrowserSessionResolver } from "./session-resolver" @@ -407,6 +408,33 @@ test("bounded tombstone table preserves live leases and rejects all future admis } }) +test("ordinary task authority can set the panel and delegated authority cannot", async () => { + const f = fixture() + const calls: string[] = [] + setBrowserPanelHandler(async (sessionID, request) => { + calls.push(`${sessionID}:${request.view}`) + return success({ + tabID: "", + url: "", + title: "", + visibleText: "", + elements: [], + panelResult: { view: "review", browserReady: false }, + }) + }) + try { + // The bridge passes task authority on every request, so an ordinary session must still reach the handler. + expect(await f.route({ op: "set_panel", view: "review" }, "parent")).toMatchObject({ ok: true }) + expect(calls).toEqual(["parent:review"]) + expect(await f.grant()).toMatchObject({ ok: true }) + expect(await f.route({ op: "set_panel", view: "review" })).toMatchObject({ ok: false, code: "access_denied" }) + expect(calls).toEqual(["parent:review"]) + } finally { + setBrowserPanelHandler(undefined) + f.close() + } +}) + test.each(["list_tabs", "prepare_write"] as const)("revoke between routing and delivery suppresses %s", async (op) => { const f = fixture() const replies: BrowserIpcResult[] = [] diff --git a/packages/desktop/src/main/browser/router.ts b/packages/desktop/src/main/browser/router.ts index 46df8d6eb3..711cbc02d7 100644 --- a/packages/desktop/src/main/browser/router.ts +++ b/packages/desktop/src/main/browser/router.ts @@ -331,7 +331,9 @@ async function route( if (!browserAgentEnabled()) return failure("access_denied", "Browser agent access is disabled in browser settings.") if (browserTaskPaused(message.sessionID)) return failure("access_denied", nativeT("desktop.browser.taskPaused")) if (parsed.op === "set_panel") { - if (access) return failure("access_denied", nativeT("desktop.browser.operationUnavailable")) + // Only a delegated subagent's authority carries a lease token. The bridge passes ordinary task + // authority on every request, and the panel handler still checks native task ownership. + if (access?.token) return failure("access_denied", nativeT("desktop.browser.operationUnavailable")) return routeBrowserPanel(message.sessionID, parsed, signal, deadline) } if (parsed.op === "prepare_tab" || "token" in parsed) diff --git a/packages/desktop/src/main/wpp-bridge/proxy/providerConfig.mjs b/packages/desktop/src/main/wpp-bridge/proxy/providerConfig.mjs index 715bdfaac5..2871ef842d 100644 --- a/packages/desktop/src/main/wpp-bridge/proxy/providerConfig.mjs +++ b/packages/desktop/src/main/wpp-bridge/proxy/providerConfig.mjs @@ -148,29 +148,8 @@ export function o1CodeConfigContent(browserPlugin, aePlugin, chromeDevTools = pr ...(chromeDevTools ? { "chrome-devtools": { ...O1_CODE_MCP["chrome-devtools"], enabled: true } } : {}), }, ...(plugins.length ? { plugin: plugins } : {}), - // AE defaults belong to its config hook, below user policy, not this high-precedence blob. - permission: { - browser_read_state: "allow", - browser_search_history: "allow", - browser_open_history: "ask", - // Lifecycle defaults come from the plugin config hook, below user policy. - browser_navigate: "allow", - browser_click: "allow", - browser_hover: "allow", - browser_drag: "allow", - browser_select_option: "allow", - browser_screenshot: "allow", - browser_visual_action: "allow", - browser_observe_console: "allow", - browser_observe_network: "allow", - browser_list_site_tools: "allow", - browser_execute_site_tool: "allow", - browser_fill: "allow", - browser_press_key: "allow", - browser_scroll: "allow", - browser_wait_for_element: "allow", - browser_wait_for_navigation: "allow", - }, + // No permission block: this blob merges after the user's global config, so a rule here would + // replace theirs. Browser and AE defaults come from their plugins' config hooks, below user policy. lsp: true, }) } diff --git a/packages/desktop/src/main/wpp-bridge/proxy/providerConfig.test.ts b/packages/desktop/src/main/wpp-bridge/proxy/providerConfig.test.ts index 9e366898f8..eb5112b0d5 100644 --- a/packages/desktop/src/main/wpp-bridge/proxy/providerConfig.test.ts +++ b/packages/desktop/src/main/wpp-bridge/proxy/providerConfig.test.ts @@ -501,7 +501,7 @@ test("leaves an unparseable file untouched", async () => { for (const browser of [false, true]) { for (const ae of [false, true]) { - test(`injected plugins browser=${browser} AE=${ae} never inject AE permissions`, () => { + test(`injected plugins browser=${browser} AE=${ae} never inject browser or AE permissions`, () => { const browserPlugin = "file:///resources/cm-browser/plugin.mjs" const aePlugin = [ "file:///resources/cm-ae/plugin.mjs", @@ -512,10 +512,9 @@ for (const browser of [false, true]) { const config = JSON.parse(o1CodeConfigContent(browser ? browserPlugin : undefined, ae ? aePlugin : undefined)) const plugins = [...(browser ? [browserPlugin] : []), ...(ae ? [aePlugin] : [])] expect(config.plugin).toEqual(plugins.length ? plugins : undefined) - expect(config.permission).toEqual(JSON.parse(o1CodeConfigContent()).permission) - expect(Object.keys(config.permission).every((name) => name.startsWith("browser_"))).toBe(true) - expect(config.permission.browser_list_site_tools).toBe("allow") - expect(config.permission.browser_execute_site_tool).toBe("allow") + // The blob merges after the user's global config, so a permission here would replace their + // rules. Browser and AE defaults come from their plugins' config hooks, beneath user policy. + expect(config.permission).toBeUndefined() // High-precedence injection cannot replace AE denies, wildcards or agent/mode policies. const policy = { permission: { ae_execute: "deny", "ae_*": "deny" }, @@ -566,27 +565,8 @@ test("injected config is self-contained for a clean bundled OpenCode install", ( }) expect(config.lsp).toBe(true) expect(config.plugin).toEqual([plugin]) - expect(config.permission).toEqual({ - browser_read_state: "allow", - browser_search_history: "allow", - browser_open_history: "ask", - browser_navigate: "allow", - browser_click: "allow", - browser_hover: "allow", - browser_drag: "allow", - browser_select_option: "allow", - browser_screenshot: "allow", - browser_visual_action: "allow", - browser_observe_console: "allow", - browser_observe_network: "allow", - browser_list_site_tools: "allow", - browser_execute_site_tool: "allow", - browser_fill: "allow", - browser_press_key: "allow", - browser_scroll: "allow", - browser_wait_for_element: "allow", - browser_wait_for_navigation: "allow", - }) + // Browser defaults come from the cm-browser config hook, beneath user policy. + expect(config.permission).toBeUndefined() expect(Object.keys(models)).toEqual(MODEL_IDS) expect(models["CM_Opus5.5-High"]).toMatchObject({ name: "CM_Opus5.5-High",