@different-ai/opencode-browser 2.1.0 → 4.0.0

package/src/plugin.ts

@@ -1,672 +1,275 @@
-/**
- * OpenCode Browser Plugin
- *
- * OpenCode Plugin (this) <--WebSocket:19222--> Chrome Extension
- *
- * Notes
- * - Uses a lock file so only one OpenCode session owns the browser.
- * - Supports a *soft takeover* (SIGUSR1) so we don't have to kill OpenCode.
- */
-
 import type { Plugin } from "@opencode-ai/plugin";
 import { tool } from "@opencode-ai/plugin";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import net from "net";
+import { existsSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+import { spawn } from "child_process";
 
-const WS_PORT = 19222;
 const BASE_DIR = join(homedir(), ".opencode-browser");
-const LOCK_FILE = join(BASE_DIR, "lock.json");
-const SCREENSHOTS_DIR = join(BASE_DIR, "screenshots");
-
-// If a session hasn't used the browser in this long, allow soft takeover by default.
-const LOCK_TTL_MS = 2 * 60 * 60 * 1000; // 2 hours
+const SOCKET_PATH = join(BASE_DIR, "broker.sock");
 
 mkdirSync(BASE_DIR, { recursive: true });
-mkdirSync(SCREENSHOTS_DIR, { recursive: true });
-
-// Session state
-const sessionId = Math.random().toString(36).slice(2);
-const pid = process.pid;
-let ws: WebSocket | null = null;
-let isConnected = false;
-let server: ReturnType<typeof Bun.serve> | null = null;
-let pendingRequests = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>();
-let requestId = 0;
-
-interface LockInfo {
-  pid: number;
-  sessionId: string;
-  startedAt: string;
-  lastUsedAt: string;
-  cwd: string;
-}
-
-function nowIso(): string {
-  return new Date().toISOString();
-}
-
-function readLock(): LockInfo | null {
-  try {
-    if (!existsSync(LOCK_FILE)) return null;
-    return JSON.parse(readFileSync(LOCK_FILE, "utf-8"));
-  } catch {
-    return null;
-  }
-}
 
-function writeLock(): void {
-  writeFileSync(
-    LOCK_FILE,
-    JSON.stringify(
-      {
-        pid,
-        sessionId,
-        startedAt: nowIso(),
-        lastUsedAt: nowIso(),
-        cwd: process.cwd(),
-      } satisfies LockInfo,
-      null,
-      2
-    ) + "\n"
-  );
-}
-
-function touchLock(): void {
-  const lock = readLock();
-  if (!lock) return;
-  if (lock.sessionId !== sessionId) return;
-
-  try {
-    writeFileSync(
-      LOCK_FILE,
-      JSON.stringify(
-        {
-          ...lock,
-          lastUsedAt: nowIso(),
-        } satisfies LockInfo,
-        null,
-        2
-      ) + "\n"
-    );
-  } catch {
-    // Ignore
-  }
-}
-
-function releaseLock(): void {
-  try {
-    const lock = readLock();
-    if (lock && lock.sessionId === sessionId) {
-      unlinkSync(LOCK_FILE);
+type BrokerResponse =
+  | { type: "response"; id: number; ok: true; data: any }
+  | { type: "response"; id: number; ok: false; error: string };
+
+function createJsonLineParser(onMessage: (msg: any) => void): (chunk: Buffer) => void {
+  let buffer = "";
+  return (chunk: Buffer) => {
+    buffer += chunk.toString("utf8");
+    while (true) {
+      const idx = buffer.indexOf("\n");
+      if (idx === -1) return;
+      const line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      if (!line.trim()) continue;
+      try {
+        onMessage(JSON.parse(line));
+      } catch {
+        // ignore
+      }
     }
-  } catch {
-    // Ignore
-  }
-}
-
-function isProcessAlive(targetPid: number): boolean {
-  try {
-    process.kill(targetPid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function lockAgeMs(lock: LockInfo): number {
-  const ts = lock.lastUsedAt || lock.startedAt;
-  const n = Date.parse(ts);
-  if (Number.isNaN(n)) return Number.POSITIVE_INFINITY;
-  return Date.now() - n;
-}
-
-function isLockExpired(lock: LockInfo): boolean {
-  return lockAgeMs(lock) > LOCK_TTL_MS;
+  };
 }
 
-function isPortFree(port: number): boolean {
-  try {
-    // If we can connect, something is already listening.
-    const testSocket = Bun.connect({ port, timeout: 300 });
-    testSocket.end();
-    return false;
-  } catch (e) {
-    if ((e as any).code === "ECONNREFUSED") return true;
-    return false;
-  }
+function writeJsonLine(socket: net.Socket, msg: any): void {
+  socket.write(JSON.stringify(msg) + "\n");
 }
 
-function stopBrowserServer(): void {
-  try {
-    (ws as any)?.close?.();
-  } catch {
-    // Ignore
-  }
-  ws = null;
-  isConnected = false;
+function maybeStartBroker(): void {
+  const brokerPath = join(BASE_DIR, "broker.cjs");
+  if (!existsSync(brokerPath)) return;
 
   try {
-    server?.stop();
+    const child = spawn(process.execPath, [brokerPath], { detached: true, stdio: "ignore" });
+    child.unref();
   } catch {
-    // Ignore
+    // ignore
   }
-  server = null;
 }
 
-function startServer(): boolean {
-  if (server) return true;
-  if (!isPortFree(WS_PORT)) return false;
-
-  try {
-    server = Bun.serve({
-      port: WS_PORT,
-      fetch(req, server) {
-        if (server.upgrade(req)) return;
-        return new Response("OpenCode Browser Plugin", { status: 200 });
-      },
-      websocket: {
-        open(wsClient) {
-          console.error(`[browser-plugin] Chrome extension connected`);
-          ws = wsClient as unknown as WebSocket;
-          isConnected = true;
-        },
-        close() {
-          console.error(`[browser-plugin] Chrome extension disconnected`);
-          ws = null;
-          isConnected = false;
-        },
-        message(_wsClient, data) {
-          try {
-            const message = JSON.parse(data.toString());
-            handleMessage(message);
-          } catch (e) {
-            console.error(`[browser-plugin] Parse error:`, e);
-          }
-        },
-      },
-    });
-
-    console.error(`[browser-plugin] WebSocket server listening on port ${WS_PORT}`);
-    return true;
-  } catch (e) {
-    console.error(`[browser-plugin] Failed to start server:`, e);
-    return false;
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+async function connectToBroker(): Promise<net.Socket> {
+  return await new Promise((resolve, reject) => {
+    const socket = net.createConnection(SOCKET_PATH);
+    socket.once("connect", () => resolve(socket));
+    socket.once("error", (err) => reject(err));
+  });
 }
 
-async function waitForExtensionConnection(timeoutMs: number): Promise<boolean> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (isConnected) return true;
-    await sleep(100);
-  }
-  return isConnected;
+async function sleep(ms: number): Promise<void> {
+  return await new Promise((r) => setTimeout(r, ms));
 }
 
-async function requestSessionRelease(targetPid: number, opts?: { timeoutMs?: number }): Promise<{ success: boolean; error?: string }> {
-  const timeoutMs = opts?.timeoutMs ?? 3000;
-
-  try {
-    // SIGUSR1 is treated as "release browser lock + stop server".
-    // This does NOT terminate OpenCode.
-    process.kill(targetPid, "SIGUSR1");
-  } catch (e) {
-    return { success: false, error: e instanceof Error ? e.message : String(e) };
-  }
+let socket: net.Socket | null = null;
+let sessionId = Math.random().toString(36).slice(2);
+let reqId = 0;
+const pending = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>();
 
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    const lock = readLock();
-    const lockCleared = !lock || lock.pid !== targetPid;
-    const portCleared = isPortFree(WS_PORT);
+async function ensureBrokerSocket(): Promise<net.Socket> {
+  if (socket && !socket.destroyed) return socket;
 
-    if (lockCleared && portCleared) return { success: true };
-    await sleep(100);
-  }
-
-  return {
-    success: false,
-    error: `Timed out waiting for PID ${targetPid} to release browser`,
-  };
-}
-
-async function forceKillSession(targetPid: number): Promise<{ success: boolean; error?: string }> {
+  // Try to connect; if missing, try to start broker and retry.
   try {
-    process.kill(targetPid, "SIGTERM");
-    let attempts = 0;
-    while (isProcessAlive(targetPid) && attempts < 20) {
+    socket = await connectToBroker();
+  } catch {
+    maybeStartBroker();
+    for (let i = 0; i < 20; i++) {
       await sleep(100);
-      attempts++;
-    }
-    if (isProcessAlive(targetPid)) {
-      process.kill(targetPid, "SIGKILL");
+      try {
+        socket = await connectToBroker();
+        break;
+      } catch {}
     }
-    return { success: true };
-  } catch (e) {
-    return { success: false, error: e instanceof Error ? e.message : String(e) };
   }
-}
-
-function handleMessage(message: { type: string; id?: number; result?: any; error?: any }): void {
-  if (message.type === "tool_response" && message.id !== undefined) {
-    const pending = pendingRequests.get(message.id);
-    if (!pending) return;
-
-    pendingRequests.delete(message.id);
-    if (message.error) {
-      pending.reject(new Error(message.error.content || String(message.error)));
-    } else {
-      pending.resolve(message.result?.content);
-    }
-  }
-}
 
-function sendToChrome(message: any): boolean {
-  if (ws && isConnected) {
-    (ws as any).send(JSON.stringify(message));
-    return true;
-  }
-  return false;
-}
-
-async function performTakeover(): Promise<string> {
-  const lock = readLock();
-
-  if (!lock) {
-    writeLock();
-  } else if (lock.sessionId === sessionId) {
-    // Already ours.
-  } else if (!isProcessAlive(lock.pid)) {
-    // Dead PID -> stale.
-    console.error(`[browser-plugin] Cleaning stale lock from dead PID ${lock.pid}`);
-    writeLock();
-  } else {
-    const ageMinutes = Math.round(lockAgeMs(lock) / 60000);
-    console.error(
-      `[browser-plugin] Requesting release from PID ${lock.pid} (last used ${ageMinutes}m ago)...`
+  if (!socket || socket.destroyed) {
+    throw new Error(
+      "Could not connect to local broker. Run `npx @different-ai/opencode-browser install` and ensure the extension is loaded."
     );
-    const released = await requestSessionRelease(lock.pid, { timeoutMs: 4000 });
-    if (!released.success) {
-      throw new Error(
-        `Failed to takeover without killing OpenCode: ${released.error}. ` +
-          `Try again, or use browser_force_kill_session as last resort.`
-      );
-    }
-    console.error(`[browser-plugin] Previous session released gracefully.`);
-    writeLock();
-  }
-
-  touchLock();
-
-  if (!server) {
-    if (!startServer()) {
-      throw new Error("Failed to start WebSocket server after takeover.");
-    }
-  }
-
-  const ok = await waitForExtensionConnection(3000);
-  if (!ok) {
-    throw new Error("Took over lock but Chrome extension did not connect.");
   }
 
-  return "Browser now connected to this session.";
-}
-
-async function ensureLockAndServer(): Promise<void> {
-  const existingLock = readLock();
-
-  if (!existingLock) {
-    writeLock();
-  } else if (existingLock.sessionId === sessionId) {
-    // Already ours.
-  } else if (!isProcessAlive(existingLock.pid)) {
-    // Stale lock (dead PID).
-    console.error(`[browser-plugin] Cleaning stale lock from dead PID ${existingLock.pid}`);
-    writeLock();
-  } else {
-    // Another session holds the lock - attempt automatic soft takeover
-    const ageMinutes = Math.round(lockAgeMs(existingLock) / 60000);
-    console.error(
-      `[browser-plugin] Browser locked by PID ${existingLock.pid} (last used ${ageMinutes}m ago). Attempting auto-takeover...`
-    );
+  socket.setNoDelay(true);
+  socket.on(
+    "data",
+    createJsonLineParser((msg) => {
+      if (msg?.type !== "response" || typeof msg.id !== "number") return;
+      const p = pending.get(msg.id);
+      if (!p) return;
+      pending.delete(msg.id);
+      const res = msg as BrokerResponse;
+      if (!res.ok) p.reject(new Error(res.error));
+      else p.resolve(res.data);
+    })
+  );
 
-    const released = await requestSessionRelease(existingLock.pid, { timeoutMs: 4000 });
-    if (released.success) {
-      console.error(`[browser-plugin] Auto-takeover succeeded. Previous session released gracefully.`);
-      writeLock();
-    } else {
-      // Soft takeover failed - provide helpful error
-      const expired = isLockExpired(existingLock);
-      const why = expired ? "expired" : "active";
-      throw new Error(
-        `Browser locked by another session (PID ${existingLock.pid}, ${why}). ` +
-          `Auto-takeover failed: ${released.error}. ` +
-          `Use browser_force_kill_session as last resort, or browser_status for details.`
-      );
-    }
-  }
+  socket.on("close", () => {
+    socket = null;
+  });
 
-  touchLock();
+  socket.on("error", () => {
+    socket = null;
+  });
 
-  if (!server) {
-    if (!startServer()) {
-      throw new Error("Failed to start WebSocket server. Port may be in use.");
-    }
-  }
+  writeJsonLine(socket, { type: "hello", role: "plugin", sessionId, pid: process.pid });
 
-  if (!isConnected) {
-    const ok = await waitForExtensionConnection(3000);
-    if (!ok) {
-      throw new Error(
-        "Chrome extension not connected. Make sure Chrome is running with the OpenCode Browser extension enabled."
-      );
-    }
-  }
+  return socket;
 }
 
-async function executeCommand(toolName: string, args: Record<string, any>): Promise<any> {
-  await ensureLockAndServer();
-
-  const id = ++requestId;
-  touchLock();
-
-  return new Promise((resolve, reject) => {
-    pendingRequests.set(id, { resolve, reject });
-
-    sendToChrome({
-      type: "tool_request",
-      id,
-      tool: toolName,
-      args,
-    });
+async function brokerRequest(op: string, payload: Record<string, any>): Promise<any> {
+  const s = await ensureBrokerSocket();
+  const id = ++reqId;
 
+  return await new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    writeJsonLine(s, { type: "request", id, op, ...payload });
     setTimeout(() => {
-      if (!pendingRequests.has(id)) return;
-      pendingRequests.delete(id);
-      reject(new Error("Tool execution timed out after 60 seconds"));
+      if (!pending.has(id)) return;
+      pending.delete(id);
+      reject(new Error("Timed out waiting for broker response"));
     }, 60000);
   });
 }
 
-// ============================================================================
-// Cleanup / Signals
-// ============================================================================
-
-// Soft release: do NOT exit the OpenCode process.
-process.on("SIGUSR1", () => {
-  console.error(`[browser-plugin] SIGUSR1: releasing lock + stopping server`);
-  releaseLock();
-  stopBrowserServer();
-});
-
-process.on("SIGTERM", () => {
-  releaseLock();
-  stopBrowserServer();
-  process.exit(0);
-});
-
-process.on("SIGINT", () => {
-  releaseLock();
-  stopBrowserServer();
-  process.exit(0);
-});
-
-process.on("exit", () => {
-  releaseLock();
-});
-
-// ============================================================================
-// Plugin Export
-// ============================================================================
-
-export const BrowserPlugin: Plugin = async (_ctx) => {
-  console.error(`[browser-plugin] Initializing (session ${sessionId})`);
-
-  return {
-    tool: {
-      browser_status: tool({
-        description:
-          "Check if browser is available or locked by another session. Returns connection status and lock info.",
-        args: {},
-        async execute() {
-          const lock = readLock();
-
-          if (!lock) {
-            return "Browser available (no active session)";
-          }
-
-          if (lock.sessionId === sessionId) {
-            return (
-              `Browser connected (this session)\n` +
-              `PID: ${pid}\n` +
-              `Started: ${lock.startedAt}\n` +
-              `Last used: ${lock.lastUsedAt}\n` +
-              `Extension: ${isConnected ? "connected" : "not connected"}`
-            );
-          }
-
-          const alive = isProcessAlive(lock.pid);
-          const ageMinutes = Math.round(lockAgeMs(lock) / 60000);
-          const expired = isLockExpired(lock);
-
-          if (!alive) {
-            return `Browser available (stale lock from dead PID ${lock.pid} will be auto-cleaned on next command)`;
-          }
-
-          return (
-            `Browser locked by another session\n` +
-            `PID: ${lock.pid}\n` +
-            `Session: ${lock.sessionId}\n` +
-            `Started: ${lock.startedAt}\n` +
-            `Last used: ${lock.lastUsedAt} (~${ageMinutes}m ago)${expired ? " [expired]" : ""}\n` +
-            `Working directory: ${lock.cwd}\n\n` +
-            `Use browser_takeover to request release (no kill), or browser_force_kill_session as last resort.`
-          );
-        },
-      }),
-
-      browser_release: tool({
-        description: "Release browser lock and stop the server for this session.",
-        args: {},
-        async execute() {
-          const lock = readLock();
-          if (lock && lock.sessionId !== sessionId) {
-            throw new Error("This session does not own the browser lock.");
-          }
-
-          releaseLock();
-          stopBrowserServer();
-          return "Released browser lock for this session.";
-        },
-      }),
-
-      browser_takeover: tool({
-        description:
-          "Request the session holding the browser lock to release it (no process kill), then take over.",
-        args: {},
-        async execute() {
-          return await performTakeover();
-        },
-      }),
-
-      browser_kill_session: tool({
-        description:
-          "(Deprecated name) Soft takeover without killing OpenCode. Prefer browser_takeover.",
-        args: {},
-        async execute() {
-          // Keep backward compatibility: old callers use this.
-          return await performTakeover();
-        },
-      }),
-
-      browser_force_kill_session: tool({
-        description: "Force kill the session holding the browser lock (last resort).",
-        args: {},
-        async execute() {
-          const lock = readLock();
-
-          if (!lock) {
-            writeLock();
-            return "No active session. Browser now connected to this session.";
-          }
-
-          if (lock.sessionId === sessionId) {
-            return "This session already owns the browser.";
-          }
-
-          if (!isProcessAlive(lock.pid)) {
-            writeLock();
-            return `Cleaned stale lock (PID ${lock.pid} was dead). Browser now connected to this session.`;
-          }
-
-          const result = await forceKillSession(lock.pid);
-          if (!result.success) {
-            throw new Error(`Failed to force kill session: ${result.error}`);
-          }
-
-          // Best-effort cleanup; then take lock.
-          try {
-            unlinkSync(LOCK_FILE);
-          } catch {
-            // Ignore
-          }
-
-          writeLock();
-
-          if (!server) {
-            if (!startServer()) {
-              throw new Error("Failed to start WebSocket server after force kill.");
-            }
-          }
-
-          const ok = await waitForExtensionConnection(3000);
-          if (!ok) {
-            throw new Error("Force-killed lock holder but Chrome extension did not connect.");
-          }
-
-          return `Force-killed session ${lock.sessionId} (PID ${lock.pid}). Browser now connected to this session.`;
-        },
-      }),
-
-      browser_navigate: tool({
-        description: "Navigate to a URL in browser",
-        args: {
-          url: tool.schema.string({ description: "The URL to navigate to" }),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("navigate", args);
-        },
-      }),
-
-      browser_click: tool({
-        description: "Click an element on page using a CSS selector",
-        args: {
-          selector: tool.schema.string({ description: "CSS selector for element to click" }),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("click", args);
-        },
-      }),
-
-      browser_type: tool({
-        description: "Type text into an input element",
-        args: {
-          selector: tool.schema.string({ description: "CSS selector for input element" }),
-          text: tool.schema.string({ description: "Text to type" }),
-          clear: tool.schema.optional(tool.schema.boolean({ description: "Clear field before typing" })),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("type", args);
-        },
-      }),
-
-      browser_screenshot: tool({
-        description: "Take a screenshot of the current page. Saves to ~/.opencode-browser/screenshots/",
-        args: {
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-          name: tool.schema.optional(
-            tool.schema.string({ description: "Optional name for screenshot file (without extension)" })
-          ),
-        },
-        async execute(args: { tabId?: number; name?: string }) {
-          const result = await executeCommand("screenshot", args);
-
-          if (result && typeof result === "string" && result.startsWith("data:image")) {
-            const base64Data = result.replace(/^data:image\/\w+;base64,/, "");
-            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-            const filename = args.name ? `${args.name}.png` : `screenshot-${timestamp}.png`;
-            const filepath = join(SCREENSHOTS_DIR, filename);
-
-            writeFileSync(filepath, Buffer.from(base64Data, "base64"));
-            return `Screenshot saved: ${filepath}`;
-          }
-
-          return result;
-        },
-      }),
-
-      browser_snapshot: tool({
-        description:
-          "Get an accessibility tree snapshot of the page. Returns interactive elements with selectors for clicking.",
-        args: {
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("snapshot", args);
-        },
-      }),
-
-      browser_get_tabs: tool({
-        description: "List all open browser tabs",
-        args: {},
-        async execute() {
-          return await executeCommand("get_tabs", {});
-        },
-      }),
-
-      browser_scroll: tool({
-        description: "Scroll the page or scroll an element into view",
-        args: {
-          selector: tool.schema.optional(tool.schema.string({ description: "CSS selector to scroll into view" })),
-          x: tool.schema.optional(tool.schema.number({ description: "Horizontal scroll amount in pixels" })),
-          y: tool.schema.optional(tool.schema.number({ description: "Vertical scroll amount in pixels" })),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("scroll", args);
-        },
-      }),
-
-      browser_wait: tool({
-        description: "Wait for a specified duration",
-        args: {
-          ms: tool.schema.optional(tool.schema.number({ description: "Milliseconds to wait (default: 1000)" })),
-        },
-        async execute(args) {
-          return await executeCommand("wait", args);
-        },
-      }),
+function toolResultText(data: any, fallback: string): string {
+  if (typeof data?.content === "string") return data.content;
+  if (typeof data === "string") return data;
+  if (data?.content != null) return JSON.stringify(data.content);
+  return fallback;
+}
 
-      browser_execute: tool({
-        description: "Execute JavaScript code in the page context and return the result",
-        args: {
-          code: tool.schema.string({ description: "JavaScript code to execute" }),
-          tabId: tool.schema.optional(tool.schema.number({ description: "Optional tab ID" })),
-        },
-        async execute(args) {
-          return await executeCommand("execute_script", args);
-        },
-      }),
-    },
-  };
+const plugin: Plugin = {
+  name: "opencode-browser",
+  tools: [
+    tool(
+      "browser_status",
+      "Check broker/native-host connection status and current tab claims.",
+      {},
+      async () => {
+        const data = await brokerRequest("status", {});
+        return JSON.stringify(data);
+      }
+    ),
+    tool(
+      "browser_get_tabs",
+      "List all open browser tabs",
+      {},
+      async () => {
+        const data = await brokerRequest("tool", { tool: "get_tabs", args: {} });
+        return toolResultText(data, "ok");
+      }
+    ),
+    tool(
+      "browser_navigate",
+      "Navigate to a URL in the browser",
+      { url: { type: "string" }, tabId: { type: "number", optional: true } },
+      async ({ url, tabId }: any) => {
+        const data = await brokerRequest("tool", { tool: "navigate", args: { url, tabId } });
+        return toolResultText(data, `Navigated to ${url}`);
+      }
+    ),
+    tool(
+      "browser_click",
+      "Click an element on the page using a CSS selector",
+      { selector: { type: "string" }, tabId: { type: "number", optional: true } },
+      async ({ selector, tabId }: any) => {
+        const data = await brokerRequest("tool", { tool: "click", args: { selector, tabId } });
+        return toolResultText(data, `Clicked ${selector}`);
+      }
+    ),
+    tool(
+      "browser_type",
+      "Type text into an input element",
+      {
+        selector: { type: "string" },
+        text: { type: "string" },
+        clear: { type: "boolean", optional: true },
+        tabId: { type: "number", optional: true },
+      },
+      async ({ selector, text, clear, tabId }: any) => {
+        const data = await brokerRequest("tool", { tool: "type", args: { selector, text, clear, tabId } });
+        return toolResultText(data, `Typed \"${text}\" into ${selector}`);
+      }
+    ),
+    tool(
+      "browser_screenshot",
+      "Take a screenshot of the current page. Returns base64 image data URL.",
+      { tabId: { type: "number", optional: true } },
+      async ({ tabId }: any) => {
+        const data = await brokerRequest("tool", { tool: "screenshot", args: { tabId } });
+        return toolResultText(data, "Screenshot failed");
+      }
+    ),
+    tool(
+      "browser_snapshot",
+      "Get an accessibility tree snapshot of the page.",
+      { tabId: { type: "number", optional: true } },
+      async ({ tabId }: any) => {
+        const data = await brokerRequest("tool", { tool: "snapshot", args: { tabId } });
+        return toolResultText(data, "Snapshot failed");
+      }
+    ),
+    tool(
+      "browser_scroll",
+      "Scroll the page or scroll an element into view",
+      {
+        selector: { type: "string", optional: true },
+        x: { type: "number", optional: true },
+        y: { type: "number", optional: true },
+        tabId: { type: "number", optional: true },
+      },
+      async ({ selector, x, y, tabId }: any) => {
+        const data = await brokerRequest("tool", { tool: "scroll", args: { selector, x, y, tabId } });
+        return toolResultText(data, "Scrolled");
+      }
+    ),
+    tool(
+      "browser_wait",
+      "Wait for a specified duration",
+      { ms: { type: "number", optional: true }, tabId: { type: "number", optional: true } },
+      async ({ ms, tabId }: any) => {
+        const data = await brokerRequest("tool", { tool: "wait", args: { ms, tabId } });
+        return toolResultText(data, "Waited");
+      }
+    ),
+    tool(
+      "browser_execute",
+      "Execute JavaScript code in the page context and return the result.",
+      { code: { type: "string" }, tabId: { type: "number", optional: true } },
+      async ({ code, tabId }: any) => {
+        const data = await brokerRequest("tool", { tool: "execute_script", args: { code, tabId } });
+        return toolResultText(data, "Execute failed");
+      }
+    ),
+    tool(
+      "browser_claim_tab",
+      "Claim a tab for this OpenCode session (per-tab ownership).",
+      { tabId: { type: "number" }, force: { type: "boolean", optional: true } },
+      async ({ tabId, force }: any) => {
+        const data = await brokerRequest("claim_tab", { tabId, force });
+        return JSON.stringify(data);
+      }
+    ),
+    tool(
+      "browser_release_tab",
+      "Release a previously claimed tab.",
+      { tabId: { type: "number" } },
+      async ({ tabId }: any) => {
+        const data = await brokerRequest("release_tab", { tabId });
+        return JSON.stringify(data);
+      }
+    ),
+    tool(
+      "browser_list_claims",
+      "List current tab ownership claims.",
+      {},
+      async () => {
+        const data = await brokerRequest("list_claims", {});
+        return JSON.stringify(data);
+      }
+    ),
+  ],
 };
 
-export default BrowserPlugin;
+export default plugin;