feat(opencode): make Browser MCP a per-thread provider setting

SDSLeon · SDSLeon · commit 9628d724247f · 2026-05-21T21:21:53.000-07:00
- expose Browser MCP toggle via OpenCode setting def and shared helper
- sync MCP config and server acquisition based on agentSettings at launch
- thread agentSettings through launch options and session manager
- render read-only Browser chip in ThreadView when setting is enabled
diff --git a/src/renderer/components/composer/AttachmentBar.tsx b/src/renderer/components/composer/AttachmentBar.tsx
@@ -4,13 +4,10 @@ import { getEntryIconUrl } from "@/renderer/components/common/fileIcons";
 import { toLocalFileUrl } from "@/shared/promptContent";
 import type { Attachment } from "./useAttachments";
 
-export function BrowserChip(props: { onRemove?: (() => void) | undefined }) {
-  const { onRemove } = props;
+export function BrowserChip(props: { onRemove?: (() => void) | undefined; title?: string }) {
+  const { onRemove, title = "Browser MCP enabled for this thread" } = props;
   return (
-    <div
-      className="lightcode-attachment-chip lightcode-browser-chip"
-      title="Browser MCP enabled for this thread"
-    >
+    <div className="lightcode-attachment-chip lightcode-browser-chip" title={title}>
       <Globe className="size-3 text-muted" />
       <span className="lightcode-attachment-chip__name">Browser</span>
       {onRemove ? (
diff --git a/src/renderer/components/thread/ThreadView.test.tsx b/src/renderer/components/thread/ThreadView.test.tsx
@@ -60,7 +60,7 @@ describe("ThreadView", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     localStorage.clear();
-    useSharedSettings.setState({ collapseTerminalComposer: false });
+    useSharedSettings.setState({ agentSettings: {}, collapseTerminalComposer: false });
     useThreadTodoDockStore.setState({
       defaultPlacement: "composer",
       defaultCollapsed: false,
@@ -137,6 +137,60 @@ describe("ThreadView", () => {
     });
   });
 
+  it("renders OpenCode Browser MCP as a read-only header chip when provider setting is enabled", () => {
+    const onConfigChange = vi.fn<(config: ThreadConfig) => void>();
+
+    renderThreadView({
+      thread: {
+        id: "thread-opencode-browser-mcp",
+        projectId: "project-1",
+        title: "OpenCode browser thread",
+        agentKind: "opencode",
+        config: {
+          model: "opencode/big-pickle",
+        },
+        status: "idle",
+        attention: "none",
+        canResumeWithConfig: true,
+        archived: false,
+        done: false,
+        starred: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+      agentStatus: {
+        kind: "opencode",
+        label: "OpenCode",
+        installed: true,
+        authState: "authenticated",
+        capabilities: {
+          models: [{ id: "opencode/big-pickle", label: "Big Pickle" }],
+          efforts: [],
+          modelEfforts: {},
+          modes: ["agent"],
+          approvalPolicies: [{ id: "default", label: "Default" }],
+          sandboxModes: [],
+          supportsResume: true,
+          supportsDirectInput: true,
+          liveInputMode: "server",
+          presentationMode: "gui",
+          settingDefs: [],
+        },
+      },
+      projectLocation: {
+        kind: "windows",
+        path: "C:\\repo",
+      },
+      onConfigChange,
+      onResolveServerRequest: async () => undefined,
+      onSubmitInput: async () => undefined,
+    });
+
+    expect(screen.getByText("Browser")).toBeInTheDocument();
+    expect(screen.queryByLabelText("Disable Browser MCP")).toBeNull();
+    expect(onConfigChange).not.toHaveBeenCalled();
+  });
+
   it("starts a queued launch after the terminal reports its first size", async () => {
     const onLaunchConsumed = vi.fn<() => void>();
 
diff --git a/src/renderer/components/thread/ThreadView.tsx b/src/renderer/components/thread/ThreadView.tsx
@@ -12,6 +12,7 @@ import type {
   ThreadServerRequestId,
 } from "@/shared/contracts";
 import { isHomeProjectId } from "@/shared/homeScope";
+import { isOpenCodeBrowserMcpEnabled } from "@/shared/opencodeSettings";
 import { buildPromptContentBlocks } from "@/shared/promptContent";
 
 import { useAppStore } from "@/renderer/state/appStore";
@@ -181,6 +182,9 @@ export const ThreadView = memo(function ThreadView(props: ThreadViewProps) {
   const launchRequestRef = useRef<string | null>(null);
   const titleRef = useRef<HTMLSpanElement>(null);
   const [isTitleTooltipOpen, setIsTitleTooltipOpen] = useState(false);
+  const opencodeBrowserMcpEnabled = useSharedSettings((s) =>
+    isOpenCodeBrowserMcpEnabled(s.agentSettings.opencode),
+  );
 
   // Thread-level mode wins over the adapter-declared default. Existing rows
   // load from DB with `presentationMode: "terminal"` thanks to the schema
@@ -189,6 +193,10 @@ export const ThreadView = memo(function ThreadView(props: ThreadViewProps) {
     (thread.presentationMode ?? agentStatus?.capabilities.presentationMode ?? "terminal") ===
     "terminal";
   const launchTerminalSize = usesTerminalPresentation ? terminalSize : DEFAULT_HIDDEN_TERMINAL_SIZE;
+  const showBrowserChip =
+    thread.config.browserMcp === true ||
+    (thread.agentKind === "opencode" && opencodeBrowserMcpEnabled);
+  const browserChipRemovable = thread.agentKind !== "opencode" && thread.config.browserMcp === true;
 
   useEffect(() => {
     const presentation =
@@ -370,10 +378,15 @@ export const ThreadView = memo(function ThreadView(props: ThreadViewProps) {
                   {thread.title}
                 </Tooltip.Content>
               </Tooltip>
-              {thread.config.browserMcp === true ? (
+              {showBrowserChip ? (
                 <div className="lightcode-overlay-header__controls shrink-0">
                   <BrowserChip
-                    onRemove={() => onConfigChange({ ...thread.config, browserMcp: false })}
+                    {...(thread.agentKind === "opencode"
+                      ? { title: "Browser MCP enabled for OpenCode" }
+                      : {})}
+                    {...(browserChipRemovable
+                      ? { onRemove: () => onConfigChange({ ...thread.config, browserMcp: false }) }
+                      : {})}
                   />
                 </div>
               ) : null}
diff --git a/src/shared/opencodeSettings.ts b/src/shared/opencodeSettings.ts
@@ -0,0 +1,9 @@
+export const OPENCODE_BROWSER_MCP_SETTING_KEY = "browserMcp";
+export const OPENCODE_BROWSER_MCP_DEFAULT = true;
+
+export function isOpenCodeBrowserMcpEnabled(
+  settings: Record<string, boolean | string> | undefined,
+): boolean {
+  const value = settings?.[OPENCODE_BROWSER_MCP_SETTING_KEY];
+  return typeof value === "boolean" ? value : OPENCODE_BROWSER_MCP_DEFAULT;
+}
diff --git a/src/supervisor/agents/base/types.ts b/src/supervisor/agents/base/types.ts
@@ -47,6 +47,7 @@ export interface AgentEnvContext {
 export interface AgentLaunchOptions {
   suppressResumeConfigOverrides?: boolean;
   resumeThreadId?: string;
+  agentSettings?: Record<string, boolean | string>;
 }
 
 export interface StructuredSessionUpdate {
@@ -107,6 +108,7 @@ export interface CreateStructuredSessionInput {
   threadId: string;
   projectLocation: ProjectLocation;
   config: ThreadConfig;
+  agentSettings?: Record<string, boolean | string>;
   sessionRef?: SessionRef;
   presentationMode?: ThreadPresentationMode;
   loadSessionErrorRewriter?: (error: unknown, sessionId: string) => Error;
diff --git a/src/supervisor/agents/opencode/detection.ts b/src/supervisor/agents/opencode/detection.ts
@@ -1,6 +1,10 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { stripAnsi } from "@/shared/ansi";
+import {
+  OPENCODE_BROWSER_MCP_DEFAULT,
+  OPENCODE_BROWSER_MCP_SETTING_KEY,
+} from "@/shared/opencodeSettings";
 import {
   type AgentSlashCommand,
   compactAgentProviderMetadata,
@@ -56,7 +60,16 @@ export const opencodeDefaultCapabilities: AgentCapability = {
   // the same SDK helper for one-shot session-id allocation.
   presentationModes: ["terminal", "gui"],
   bypassApprovalPolicy: "yolo",
-  settingDefs: [],
+  settingDefs: [
+    {
+      key: OPENCODE_BROWSER_MCP_SETTING_KEY,
+      type: "toggle",
+      env: {},
+      label: "Use Browser",
+      description: "Expose Lightcode's internal browser to OpenCode via MCP.",
+      default: OPENCODE_BROWSER_MCP_DEFAULT,
+    },
+  ],
 };
 
 /**
diff --git a/src/supervisor/agents/opencode/index.ts b/src/supervisor/agents/opencode/index.ts
@@ -1,4 +1,5 @@
 import type { AgentCapability, PromptSegment } from "@/shared/contracts";
+import { isOpenCodeBrowserMcpEnabled } from "@/shared/opencodeSettings";
 import { EXTRACTION_PROMPT } from "@/supervisor/contextExtractor";
 import {
   createKnownSessionRef,
@@ -17,6 +18,7 @@ import {
   installOpenCodePlugin,
   isOpenCodePluginInstalled,
   readBundledOpenCodePluginVersion,
+  syncOpenCodeBrowserMcpConfigFile,
   uninstallOpenCodePlugin,
 } from "./plugin/install";
 import { runOpenCodeOneShot } from "./sdkOneShot";
@@ -105,6 +107,10 @@ export function createOpenCodeAdapter(): AgentAdapter {
     // so the supervisor knows the providerSessionId synchronously instead of
     // polling `opencode session list` after spawn.
     buildLaunchArgv(_location, config, prompt, _sessionRef, launchOptions) {
+      syncOpenCodeBrowserMcpConfigFile(
+        _location,
+        isOpenCodeBrowserMcpEnabled(launchOptions?.agentSettings),
+      );
       const sessionId = launchOptions?.resumeThreadId;
       const args = buildOpenCodeArgs(config, prompt, sessionId);
       return {
@@ -113,7 +119,11 @@ export function createOpenCodeAdapter(): AgentAdapter {
         ...(sessionId ? { sessionRef: createKnownSessionRef(sessionId) } : {}),
       };
     },
-    buildResumeArgv(_location, config, prompt, sessionRef) {
+    buildResumeArgv(_location, config, prompt, sessionRef, launchOptions) {
+      syncOpenCodeBrowserMcpConfigFile(
+        _location,
+        isOpenCodeBrowserMcpEnabled(launchOptions?.agentSettings),
+      );
       return {
         binary: "opencode",
         args: buildOpenCodeArgs(config, prompt, sessionRef.providerSessionId),
diff --git a/src/supervisor/agents/opencode/plugin/install.ts b/src/supervisor/agents/opencode/plugin/install.ts
@@ -10,6 +10,7 @@ import {
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import type { ProjectLocation } from "@/shared/contracts";
 import { toWslUncPath } from "@/shared/wsl";
 import type { AgentEnvContext } from "../../base";
 import { resolveWslHomeDirectory } from "../../base";
@@ -233,11 +234,10 @@ export function installOpenCodePlugin(
   }
 
   // Best-effort: scrub the dead `file://...` entry older lightcode versions
-  // wrote into opencode.json, and merge the browser MCP entry in one
-  // read/write cycle. Failure here doesn't block install — the plugin is
-  // already loadable via auto-discovery.
+  // wrote into opencode.json. Browser MCP is synced at OpenCode launch time so
+  // it can honor the user's provider setting.
   const nativeConfigPath = join(resolveOpenCodeNativeConfigDir(), OPENCODE_CONFIG_FILE_NAME);
-  updateOpenCodeConfigFile(nativeConfigPath, buildOpenCodeBrowserMcp({ kind: "windows" }));
+  updateOpenCodeConfigFile(nativeConfigPath, undefined);
 
   console.log(
     `[supervisor] OpenCode hook plugin staged v${manifest.version} at ${pluginDir} ` +
@@ -286,11 +286,12 @@ function installOpenCodePluginWsl(
     };
   }
 
-  // Same scrub on the WSL-side opencode.json — in one read/write cycle.
+  // Same scrub on the WSL-side opencode.json. Browser MCP is synced at launch
+  // time so it can honor the user's provider setting.
   const cfgDir = resolveOpenCodeWslConfigDir(distro);
   if (cfgDir) {
     const wslConfigPath = `${cfgDir.uncDir}\\${OPENCODE_CONFIG_FILE_NAME}`;
-    updateOpenCodeConfigFile(wslConfigPath, buildOpenCodeBrowserMcp({ kind: "wsl", distro }));
+    updateOpenCodeConfigFile(wslConfigPath, undefined);
   }
 
   console.log(
@@ -469,6 +470,26 @@ function updateOpenCodeConfigFile(configPath: string, servers: BrowserMcpServers
   }
 }
 
+export function syncOpenCodeBrowserMcpConfigFile(
+  location: ProjectLocation,
+  enabled: boolean,
+): void {
+  if (location.kind === "wsl") {
+    const cfgDir = resolveOpenCodeWslConfigDir(location.distro);
+    if (!cfgDir) return;
+    updateOpenCodeConfigFile(
+      `${cfgDir.uncDir}\\${OPENCODE_CONFIG_FILE_NAME}`,
+      enabled ? buildOpenCodeBrowserMcp(location) : undefined,
+    );
+    return;
+  }
+
+  updateOpenCodeConfigFile(
+    join(resolveOpenCodeNativeConfigDir(), OPENCODE_CONFIG_FILE_NAME),
+    enabled ? buildOpenCodeBrowserMcp(location) : undefined,
+  );
+}
+
 /**
  * Removes the dropped plugin file from OpenCode's plugins/ directory and any
  * legacy drops, plus scrubs the lightcode entry from opencode.json. Staging
diff --git a/src/supervisor/agents/opencode/sdkClient.ts b/src/supervisor/agents/opencode/sdkClient.ts
@@ -1,7 +1,9 @@
 import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
 import type { ProjectLocation } from "@/shared/contracts";
 import { resolveAgentBinaryPath } from "../binaryResolver";
+import { BROWSER_MCP_SERVER_NAME } from "../browserMcp";
 import { buildOpenCodeServerCommand } from "./argv";
+import { buildOpenCodeBrowserMcp } from "./mcpBrowser";
 import { spawnOpenCodeServer, type OpenCodeServerHandle } from "./sdkServer";
 
 /** Agent-side cwd that the SDK passes through to the server's session config. */
@@ -97,6 +99,7 @@ async function spawnAndWire(projectLocation: ProjectLocation): Promise<ServerSna
  */
 export interface AcquireOpenCodeServerInput {
   projectLocation: ProjectLocation;
+  browserMcpEnabled?: boolean;
   /**
    * If set, the server stays alive for this many milliseconds after the last
    * release before being torn down. A re-acquire within the window reuses the
@@ -106,6 +109,29 @@ export interface AcquireOpenCodeServerInput {
   idleCloseDelayMs?: number;
 }
 
+async function syncBrowserMcp(
+  input: Pick<AcquireOpenCodeServerInput, "projectLocation" | "browserMcpEnabled">,
+  client: OpencodeClient,
+): Promise<void> {
+  const directory = resolveOpenCodeSessionDirectory(input.projectLocation);
+  if (input.browserMcpEnabled === undefined) return;
+  if (!input.browserMcpEnabled) {
+    await client.mcp
+      .disconnect({ directory, name: BROWSER_MCP_SERVER_NAME })
+      .catch(() => undefined);
+    return;
+  }
+
+  const servers = buildOpenCodeBrowserMcp(input.projectLocation);
+  const browser = servers?.[BROWSER_MCP_SERVER_NAME];
+  if (!browser) return;
+
+  await client.mcp
+    .add({ directory, name: BROWSER_MCP_SERVER_NAME, config: browser })
+    .catch(() => undefined);
+  await client.mcp.connect({ directory, name: BROWSER_MCP_SERVER_NAME });
+}
+
 export async function acquireOpenCodeServer(
   input: AcquireOpenCodeServerInput,
 ): Promise<AcquiredOpenCodeServer> {
@@ -153,6 +179,10 @@ export async function acquireOpenCodeServer(
 
   let released = false;
   const idleCloseDelayMs = input.idleCloseDelayMs;
+  await syncBrowserMcp(input, snapshot.client).catch((error) => {
+    console.warn("[opencode] failed to sync Browser MCP:", error);
+  });
+
   return {
     client: snapshot.client,
     baseUrl: snapshot.baseUrl,
diff --git a/src/supervisor/agents/opencode/sdkSession.ts b/src/supervisor/agents/opencode/sdkSession.ts
@@ -29,6 +29,7 @@ import type {
   ThreadStatus,
 } from "@/shared/contracts";
 import { areAgentSlashCommandsEqual } from "@/shared/contracts";
+import { isOpenCodeBrowserMcpEnabled } from "@/shared/opencodeSettings";
 import {
   createKnownSessionRef,
   type AgentLaunchOptions,
@@ -47,6 +48,7 @@ import {
 import { mapOpenCodeSlashCommands } from "./detection";
 import { classifyOpenCodeError } from "./opencodeErrors";
 import { buildOpenCodePermissionRules } from "./permissionRules";
+import { syncOpenCodeBrowserMcpConfigFile } from "./plugin/install";
 import {
   acquireOpenCodeServer,
   resolveOpenCodeSessionDirectory,
@@ -351,8 +353,11 @@ export class OpencodeSdkSession implements StructuredSessionHandle {
     this.activated = true;
 
     try {
+      const browserMcpEnabled = isOpenCodeBrowserMcpEnabled(this.input.agentSettings);
+      syncOpenCodeBrowserMcpConfigFile(this.input.projectLocation, browserMcpEnabled);
       this.acquired = await acquireOpenCodeServer({
         projectLocation: this.input.projectLocation,
+        browserMcpEnabled,
       });
     } catch (cause) {
       // Surface server-startup failures (sandbox blocks, ENOENT, port races,
diff --git a/src/supervisor/runtime/threadSessionManager.ts b/src/supervisor/runtime/threadSessionManager.ts
