@different-ai/opencode-browser 4.3.2 → 4.5.0

package/dist/plugin.js

@@ -12330,22 +12330,700 @@ function tool(input) {
 }
 tool.schema = exports_external;
 // src/plugin.ts
+import net2 from "net";
+
+// src/agent-backend.ts
 import net from "net";
-import { existsSync, mkdirSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
+import { readFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
 import { spawn } from "child_process";
+import { createRequire } from "module";
+var agentRequire = createRequire(import.meta.url);
+var REQUEST_TIMEOUT_MS = 60000;
+var DEFAULT_PAGE_TEXT_LIMIT = 20000;
+var DEFAULT_LIST_LIMIT = 50;
+var DEFAULT_POLL_MS = 200;
+function createJsonLineParser(onMessage) {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk.toString("utf8");
+    while (true) {
+      const idx = buffer.indexOf(`
+`);
+      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 {}
+    }
+  };
+}
+function writeJsonLine(socket, msg) {
+  socket.write(JSON.stringify(msg) + `
+`);
+}
+async function sleep(ms) {
+  return await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseEnvNumber(value) {
+  if (!value)
+    return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function getAgentSession(sessionId) {
+  const override = process.env.OPENCODE_BROWSER_AGENT_SESSION?.trim();
+  if (override)
+    return override;
+  return `opencode-${sessionId}`;
+}
+function getAgentPortForSession(session) {
+  let hash2 = 0;
+  for (let i = 0;i < session.length; i++) {
+    hash2 = (hash2 << 5) - hash2 + session.charCodeAt(i);
+    hash2 |= 0;
+  }
+  return 49152 + Math.abs(hash2) % 16383;
+}
+function getAgentConnectionInfo(session) {
+  const socketOverride = process.env.OPENCODE_BROWSER_AGENT_SOCKET?.trim();
+  if (socketOverride) {
+    return { type: "unix", path: socketOverride };
+  }
+  const hostOverride = process.env.OPENCODE_BROWSER_AGENT_HOST?.trim();
+  const portOverride = parseEnvNumber(process.env.OPENCODE_BROWSER_AGENT_PORT);
+  const transportOverride = process.env.OPENCODE_BROWSER_AGENT_TRANSPORT?.toLowerCase();
+  const forceTcp = transportOverride === "tcp" || process.env.OPENCODE_BROWSER_AGENT_TCP === "1";
+  if (hostOverride || portOverride !== null || forceTcp || process.platform === "win32") {
+    const host = hostOverride || "127.0.0.1";
+    const port = portOverride ?? getAgentPortForSession(session);
+    return { type: "tcp", host, port };
+  }
+  return { type: "unix", path: join(tmpdir(), `agent-browser-${session}.sock`) };
+}
+function isLocalHost(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+function resolveAgentDaemonPath() {
+  const override = process.env.OPENCODE_BROWSER_AGENT_DAEMON?.trim();
+  if (override)
+    return override;
+  try {
+    return agentRequire.resolve("agent-browser/dist/daemon.js");
+  } catch {
+    return null;
+  }
+}
+function resolveAgentNodePath() {
+  const override = process.env.OPENCODE_BROWSER_AGENT_NODE?.trim();
+  return override || process.execPath;
+}
+function getAgentPackageVersion() {
+  try {
+    const pkgPath = agentRequire.resolve("agent-browser/package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return typeof pkg?.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function shouldAutoStartAgent(connection) {
+  const autoStart = process.env.OPENCODE_BROWSER_AGENT_AUTOSTART?.toLowerCase();
+  if (autoStart && ["0", "false", "no"].includes(autoStart))
+    return false;
+  if (connection.type === "unix")
+    return true;
+  return connection.type === "tcp" && process.platform === "win32" && isLocalHost(connection.host);
+}
+async function maybeStartAgentDaemon(connection, session) {
+  if (!shouldAutoStartAgent(connection))
+    return;
+  const daemonPath = resolveAgentDaemonPath();
+  if (!daemonPath) {
+    throw new Error("agent-browser dependency not found. Install agent-browser or set OPENCODE_BROWSER_AGENT_DAEMON.");
+  }
+  try {
+    const child = spawn(resolveAgentNodePath(), [daemonPath], {
+      detached: true,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        AGENT_BROWSER_SESSION: session,
+        AGENT_BROWSER_DAEMON: "1"
+      }
+    });
+    child.unref();
+  } catch {}
+}
+function buildEvalScript(body) {
+  return `(() => { ${body} })()`;
+}
+function buildAgentTypeScript(selector, indexValue, text, clear) {
+  const payload = { selector, index: indexValue, text, clear };
+  return buildEvalScript(`
+    const payload = ${JSON.stringify(payload)};
+    let matches = [];
+    try {
+      matches = Array.from(document.querySelectorAll(payload.selector));
+    } catch {
+      return { ok: false, error: "Invalid selector" };
+    }
+    const element = matches[payload.index];
+    if (!element) return { ok: false, error: "Element not found" };
+    const tag = element.tagName ? element.tagName.toUpperCase() : "";
+    if (tag === "INPUT" || tag === "TEXTAREA") {
+      if (payload.clear) element.value = "";
+      element.value = (element.value || "") + payload.text;
+      element.dispatchEvent(new Event("input", { bubbles: true }));
+      element.dispatchEvent(new Event("change", { bubbles: true }));
+      return { ok: true };
+    }
+    if (element.isContentEditable) {
+      if (payload.clear) element.textContent = "";
+      element.textContent = (element.textContent || "") + payload.text;
+      element.dispatchEvent(new Event("input", { bubbles: true }));
+      return { ok: true };
+    }
+    return { ok: false, error: "Element is not typable" };
+  `);
+}
+function buildAgentSelectScript(selector, indexValue, value, label, optionIndex) {
+  const payload = {
+    selector,
+    index: indexValue,
+    value: value ?? null,
+    label: label ?? null,
+    optionIndex: Number.isFinite(optionIndex) ? optionIndex : null
+  };
+  return buildEvalScript(`
+    const payload = ${JSON.stringify(payload)};
+    let matches = [];
+    try {
+      matches = Array.from(document.querySelectorAll(payload.selector));
+    } catch {
+      return { ok: false, error: "Invalid selector" };
+    }
+    const element = matches[payload.index];
+    if (!element) return { ok: false, error: "Element not found" };
+    if (!element.tagName || element.tagName.toUpperCase() !== "SELECT") {
+      return { ok: false, error: "Element is not a select" };
+    }
+    const options = Array.from(element.options || []);
+    let chosen = null;
+    if (payload.value !== null) {
+      chosen = options.find((option) => option.value === payload.value) || null;
+    }
+    if (!chosen && payload.label !== null) {
+      const target = payload.label.trim();
+      chosen = options.find((option) => (option.label || option.textContent || "").trim() === target) || null;
+    }
+    if (!chosen && payload.optionIndex !== null) {
+      chosen = options[payload.optionIndex] || null;
+    }
+    if (!chosen) return { ok: false, error: "Option not found" };
+    element.value = chosen.value;
+    chosen.selected = true;
+    element.dispatchEvent(new Event("input", { bubbles: true }));
+    element.dispatchEvent(new Event("change", { bubbles: true }));
+    return {
+      ok: true,
+      value: element.value,
+      label: (chosen.label || chosen.textContent || "").trim(),
+    };
+  `);
+}
+function buildAgentPageTextScript(limit, pattern, flags) {
+  const payload = { limit, pattern, flags };
+  return buildEvalScript(`
+    const payload = ${JSON.stringify(payload)};
+    const safeString = (value) => (typeof value === "string" ? value : "");
+    const bodyText = safeString(document.body ? document.body.innerText : "");
+    const inputText = Array.from(document.querySelectorAll("input, textarea, [contenteditable='true']"))
+      .map((element) => {
+        if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+          return safeString(element.value);
+        }
+        return safeString(element.textContent);
+      })
+      .filter(Boolean)
+      .join("
+");
+    const combined = [bodyText, inputText].filter(Boolean).join("
+
+");
+    const maxSize = Number.isFinite(payload.limit) ? payload.limit : ${DEFAULT_PAGE_TEXT_LIMIT};
+    const text = combined.slice(0, Math.max(0, maxSize));
+    let matches = [];
+    if (payload.pattern) {
+      try {
+        const re = new RegExp(payload.pattern, payload.flags || "i");
+        let match;
+        while ((match = re.exec(text)) && matches.length < 50) {
+          matches.push(match[0]);
+          if (!re.global) break;
+        }
+      } catch {
+        matches = [];
+      }
+    }
+    return {
+      url: location.href,
+      title: document.title,
+      text,
+      matches,
+    };
+  `);
+}
+function buildAgentListScript(selector, limit) {
+  const payload = { selector, limit };
+  return buildEvalScript(`
+    const payload = ${JSON.stringify(payload)};
+    let nodes = [];
+    try {
+      nodes = Array.from(document.querySelectorAll(payload.selector));
+    } catch {
+      return { ok: false, error: "Invalid selector" };
+    }
+    const maxItems = Math.min(Math.max(1, payload.limit || ${DEFAULT_LIST_LIMIT}), 200);
+    const items = nodes.slice(0, maxItems).map((element) => ({
+      text: (element.innerText || element.textContent || "").trim().slice(0, 200),
+      tag: (element.tagName || "").toLowerCase(),
+      ariaLabel: element.getAttribute ? element.getAttribute("aria-label") : null,
+    }));
+    return { ok: true, value: { items, count: nodes.length } };
+  `);
+}
+function buildAgentNthValueScript(selector, indexValue) {
+  const payload = { selector, index: indexValue };
+  return buildEvalScript(`
+    const payload = ${JSON.stringify(payload)};
+    let nodes = [];
+    try {
+      nodes = Array.from(document.querySelectorAll(payload.selector));
+    } catch {
+      return { ok: false, error: "Invalid selector" };
+    }
+    const element = nodes[payload.index];
+    if (!element) return { ok: false, error: "Element not found" };
+    const value = element.value !== undefined ? element.value : "";
+    return { ok: true, value: typeof value === "string" ? value : String(value ?? "") };
+  `);
+}
+function buildAgentNthAttributeScript(selector, indexValue, attribute) {
+  const payload = { selector, index: indexValue, attribute };
+  return buildEvalScript(`
+    const payload = ${JSON.stringify(payload)};
+    let nodes = [];
+    try {
+      nodes = Array.from(document.querySelectorAll(payload.selector));
+    } catch {
+      return { ok: false, error: "Invalid selector" };
+    }
+    const element = nodes[payload.index];
+    if (!element) return { ok: false, error: "Element not found" };
+    const value = element.getAttribute ? element.getAttribute(payload.attribute) : null;
+    return { ok: true, value };
+  `);
+}
+function buildAgentNthPropertyScript(selector, indexValue, property) {
+  const payload = { selector, index: indexValue, property };
+  return buildEvalScript(`
+    const payload = ${JSON.stringify(payload)};
+    let nodes = [];
+    try {
+      nodes = Array.from(document.querySelectorAll(payload.selector));
+    } catch {
+      return { ok: false, error: "Invalid selector" };
+    }
+    const element = nodes[payload.index];
+    if (!element) return { ok: false, error: "Element not found" };
+    return { ok: true, value: element[payload.property] };
+  `);
+}
+function buildAgentOuterHtmlScript(selector, indexValue) {
+  const payload = { selector, index: indexValue };
+  return buildEvalScript(`
+    const payload = ${JSON.stringify(payload)};
+    let nodes = [];
+    try {
+      nodes = Array.from(document.querySelectorAll(payload.selector));
+    } catch {
+      return { ok: false, error: "Invalid selector" };
+    }
+    const element = nodes[payload.index];
+    if (!element) return { ok: false, error: "Element not found" };
+    return { ok: true, value: element.outerHTML };
+  `);
+}
+function ensureEvalResult(result, fallback) {
+  if (!result || typeof result !== "object" || result.ok !== true) {
+    const message = typeof result?.error === "string" ? result.error : fallback;
+    throw new Error(message);
+  }
+  return result.value;
+}
+function createAgentBackend(sessionId) {
+  const session = getAgentSession(sessionId);
+  const connection = getAgentConnectionInfo(session);
+  let agentSocket = null;
+  let agentReqId = 0;
+  const agentPending = new Map;
+  async function connectToAgent() {
+    return await new Promise((resolve, reject) => {
+      const socket = connection.type === "unix" ? net.createConnection(connection.path) : net.createConnection({ host: connection.host, port: connection.port });
+      socket.once("connect", () => resolve(socket));
+      socket.once("error", (err) => reject(err));
+    });
+  }
+  async function ensureAgentSocket() {
+    if (agentSocket && !agentSocket.destroyed)
+      return agentSocket;
+    try {
+      agentSocket = await connectToAgent();
+    } catch {
+      await maybeStartAgentDaemon(connection, session);
+      for (let attempt = 0;attempt < 20; attempt++) {
+        await sleep(100);
+        try {
+          agentSocket = await connectToAgent();
+          break;
+        } catch {}
+      }
+    }
+    if (!agentSocket || agentSocket.destroyed) {
+      const target = connection.type === "unix" ? connection.path : `${connection.host}:${connection.port}`;
+      throw new Error(`Could not connect to agent-browser daemon at ${target}.`);
+    }
+    agentSocket.setNoDelay(true);
+    agentSocket.on("data", createJsonLineParser((msg) => {
+      if (!msg || msg.id === undefined)
+        return;
+      const messageId = typeof msg.id === "string" ? msg.id : String(msg.id);
+      const pending = agentPending.get(messageId);
+      if (!pending)
+        return;
+      agentPending.delete(messageId);
+      const res = msg;
+      if (!res.success)
+        pending.reject(new Error(res.error || "Agent browser error"));
+      else
+        pending.resolve(res.data);
+    }));
+    agentSocket.on("close", () => {
+      for (const pending of agentPending.values()) {
+        pending.reject(new Error("Agent browser connection closed"));
+      }
+      agentPending.clear();
+      agentSocket = null;
+    });
+    agentSocket.on("error", () => {
+      agentSocket = null;
+    });
+    return agentSocket;
+  }
+  async function agentRequest(action, payload) {
+    const socket = await ensureAgentSocket();
+    const id = `a${++agentReqId}`;
+    return await new Promise((resolve, reject) => {
+      agentPending.set(id, { resolve, reject });
+      writeJsonLine(socket, { id, action, ...payload });
+      setTimeout(() => {
+        if (!agentPending.has(id))
+          return;
+        agentPending.delete(id);
+        reject(new Error("Timed out waiting for agent-browser response"));
+      }, REQUEST_TIMEOUT_MS);
+    });
+  }
+  async function agentCommand(action, payload) {
+    return await agentRequest(action, payload);
+  }
+  async function withTab(tabId, action) {
+    if (!Number.isFinite(tabId))
+      return await action();
+    await agentCommand("tab_switch", { index: tabId });
+    return await action();
+  }
+  async function agentEvaluate(script) {
+    const data = await agentCommand("evaluate", { script });
+    return data?.result;
+  }
+  async function waitForCount(selector, minimum, timeoutMs, pollMs) {
+    const timeout = Math.max(0, timeoutMs);
+    const poll = Math.max(0, pollMs || DEFAULT_POLL_MS);
+    const start = Date.now();
+    while (true) {
+      const data = await agentCommand("count", { selector });
+      const count = Number(data?.count ?? 0);
+      if (count >= minimum)
+        return count;
+      if (!timeout || Date.now() - start >= timeout)
+        return count;
+      await sleep(poll);
+    }
+  }
+  async function agentQuery(args) {
+    const selector = typeof args.selector === "string" ? args.selector : undefined;
+    const mode = typeof args.mode === "string" && args.mode ? args.mode : "text";
+    const indexValue = Number.isFinite(args.index) ? args.index : 0;
+    const limitValue = Number.isFinite(args.limit) ? args.limit : mode === "page_text" ? DEFAULT_PAGE_TEXT_LIMIT : DEFAULT_LIST_LIMIT;
+    const timeoutValue = Number.isFinite(args.timeoutMs) ? args.timeoutMs : 0;
+    const pollValue = Number.isFinite(args.pollMs) ? args.pollMs : DEFAULT_POLL_MS;
+    const pattern = typeof args.pattern === "string" ? args.pattern : null;
+    const flags = typeof args.flags === "string" ? args.flags : "i";
+    if (mode === "page_text") {
+      if (selector && timeoutValue > 0) {
+        await waitForCount(selector, 1, timeoutValue, pollValue);
+      }
+      const pageText = await agentEvaluate(buildAgentPageTextScript(limitValue, pattern, flags));
+      return { content: JSON.stringify({ ok: true, value: pageText }, null, 2) };
+    }
+    if (!selector)
+      throw new Error("selector is required");
+    if (mode === "exists") {
+      const count2 = await waitForCount(selector, 1, timeoutValue, pollValue);
+      return {
+        content: JSON.stringify({ ok: true, value: { exists: count2 > 0, count: count2 } }, null, 2)
+      };
+    }
+    const count = await waitForCount(selector, indexValue + 1, timeoutValue, pollValue);
+    if (count <= indexValue) {
+      throw new Error(`No matches for selector: ${selector}`);
+    }
+    if (mode === "text") {
+      const data = indexValue > 0 ? await agentCommand("nth", { selector, index: indexValue, subaction: "text" }) : await agentCommand("innertext", { selector });
+      return { content: typeof data?.text === "string" ? data.text : "" };
+    }
+    if (mode === "value") {
+      if (indexValue > 0) {
+        const result = ensureEvalResult(await agentEvaluate(buildAgentNthValueScript(selector, indexValue)), "Value lookup failed");
+        return { content: typeof result === "string" ? result : JSON.stringify(result) };
+      }
+      const data = await agentCommand("inputvalue", { selector });
+      return { content: typeof data?.value === "string" ? data.value : "" };
+    }
+    if (mode === "attribute") {
+      if (!args.attribute)
+        throw new Error("attribute is required");
+      if (indexValue > 0) {
+        const result = ensureEvalResult(await agentEvaluate(buildAgentNthAttributeScript(selector, indexValue, args.attribute)), "Attribute lookup failed");
+        return { content: typeof result === "string" ? result : JSON.stringify(result) };
+      }
+      const data = await agentCommand("getattribute", { selector, attribute: args.attribute });
+      return { content: typeof data?.value === "string" ? data.value : JSON.stringify(data?.value) };
+    }
+    if (mode === "property") {
+      if (!args.property)
+        throw new Error("property is required");
+      const result = ensureEvalResult(await agentEvaluate(buildAgentNthPropertyScript(selector, indexValue, args.property)), "Property lookup failed");
+      return { content: typeof result === "string" ? result : JSON.stringify(result) };
+    }
+    if (mode === "html") {
+      const result = ensureEvalResult(await agentEvaluate(buildAgentOuterHtmlScript(selector, indexValue)), "HTML lookup failed");
+      return { content: typeof result === "string" ? result : JSON.stringify(result) };
+    }
+    if (mode === "list") {
+      const listResult = ensureEvalResult(await agentEvaluate(buildAgentListScript(selector, limitValue)), "List lookup failed");
+      return { content: JSON.stringify({ ok: true, value: listResult }, null, 2) };
+    }
+    throw new Error(`Unknown mode: ${mode}`);
+  }
+  async function requestTool(tool3, args) {
+    switch (tool3) {
+      case "get_tabs": {
+        const data = await agentCommand("tab_list", {});
+        const tabs = Array.isArray(data?.tabs) ? data.tabs : [];
+        const mapped = tabs.map((tab) => ({
+          id: tab.index,
+          url: tab.url,
+          title: tab.title,
+          active: tab.active,
+          windowId: tab.windowId ?? 0
+        }));
+        return { content: JSON.stringify(mapped, null, 2) };
+      }
+      case "open_tab": {
+        const active = args.active;
+        let previousActive = null;
+        if (active === false) {
+          const list = await agentCommand("tab_list", {});
+          if (Number.isFinite(list?.active))
+            previousActive = list.active;
+        }
+        const created = await agentCommand("tab_new", {});
+        if (args.url) {
+          await agentCommand("navigate", { url: args.url });
+        }
+        if (active === false && previousActive !== null) {
+          await agentCommand("tab_switch", { index: previousActive });
+        }
+        return { content: { tabId: created.index, url: args.url, active: active !== false } };
+      }
+      case "navigate": {
+        return await withTab(args.tabId, async () => {
+          if (!args.url)
+            throw new Error("URL is required");
+          await agentCommand("navigate", { url: args.url });
+          return { content: `Navigated to ${args.url}` };
+        });
+      }
+      case "click": {
+        return await withTab(args.tabId, async () => {
+          if (!args.selector)
+            throw new Error("Selector is required");
+          const indexValue = Number.isFinite(args.index) ? args.index : 0;
+          if (indexValue) {
+            await agentCommand("nth", { selector: args.selector, index: indexValue, subaction: "click" });
+          } else {
+            await agentCommand("click", { selector: args.selector });
+          }
+          return { content: `Clicked ${args.selector}` };
+        });
+      }
+      case "type": {
+        return await withTab(args.tabId, async () => {
+          if (!args.selector)
+            throw new Error("Selector is required");
+          if (args.text === undefined)
+            throw new Error("Text is required");
+          const indexValue = Number.isFinite(args.index) ? args.index : 0;
+          if (!indexValue) {
+            await agentCommand("type", {
+              selector: args.selector,
+              text: String(args.text),
+              clear: args.clear
+            });
+          } else {
+            const result = await agentEvaluate(buildAgentTypeScript(args.selector, indexValue, String(args.text), !!args.clear));
+            if (!result?.ok) {
+              throw new Error(result?.error || "Type failed");
+            }
+          }
+          return { content: `Typed "${args.text}" into ${args.selector}` };
+        });
+      }
+      case "select": {
+        return await withTab(args.tabId, async () => {
+          if (!args.selector)
+            throw new Error("Selector is required");
+          if (args.value === undefined && args.label === undefined && args.optionIndex === undefined) {
+            throw new Error("value, label, or optionIndex is required");
+          }
+          const indexValue = Number.isFinite(args.index) ? args.index : 0;
+          let selectedValue = args.value;
+          let selectedLabel = args.label;
+          if (indexValue || args.label !== undefined || args.optionIndex !== undefined) {
+            const result = await agentEvaluate(buildAgentSelectScript(args.selector, indexValue, args.value, args.label, args.optionIndex));
+            if (!result?.ok) {
+              throw new Error(result?.error || "Select failed");
+            }
+            selectedValue = result.value;
+            selectedLabel = result.label;
+          } else if (args.value !== undefined) {
+            await agentCommand("select", { selector: args.selector, values: args.value });
+          }
+          const valueText = selectedValue ? String(selectedValue) : "";
+          const labelText = selectedLabel ? String(selectedLabel) : "";
+          const summary = labelText && valueText && labelText !== valueText ? `${labelText} (${valueText})` : labelText || valueText || "option";
+          return { content: `Selected ${summary} in ${args.selector}` };
+        });
+      }
+      case "screenshot": {
+        return await withTab(args.tabId, async () => {
+          const data = await agentCommand("screenshot", { format: "png" });
+          const base643 = data?.base64 ? String(data.base64) : "";
+          if (!base643)
+            throw new Error("Screenshot failed");
+          return { content: `data:image/png;base64,${base643}` };
+        });
+      }
+      case "snapshot": {
+        return await withTab(args.tabId, async () => {
+          const data = await agentCommand("snapshot", {});
+          const payload = {
+            snapshot: data?.snapshot ?? "",
+            refs: data?.refs ?? {}
+          };
+          return { content: JSON.stringify(payload, null, 2) };
+        });
+      }
+      case "query": {
+        return await withTab(args.tabId, async () => {
+          return await agentQuery(args);
+        });
+      }
+      case "scroll": {
+        return await withTab(args.tabId, async () => {
+          const x = Number.isFinite(args.x) ? args.x : 0;
+          const y = Number.isFinite(args.y) ? args.y : 0;
+          await agentCommand("scroll", {
+            selector: args.selector,
+            x,
+            y
+          });
+          const target = args.selector ? `to ${args.selector}` : `by (${x}, ${y})`;
+          return { content: `Scrolled ${target}` };
+        });
+      }
+      case "wait": {
+        return await withTab(args.tabId, async () => {
+          const ms = Number.isFinite(args.ms) ? args.ms : 1000;
+          await agentCommand("wait", { timeout: ms });
+          return { content: `Waited ${ms}ms` };
+        });
+      }
+      default:
+        throw new Error(`Unsupported tool for agent backend: ${tool3}`);
+    }
+  }
+  async function status() {
+    let connected = false;
+    let error45;
+    try {
+      await ensureAgentSocket();
+      connected = true;
+    } catch (err) {
+      error45 = err instanceof Error ? err.message : String(err);
+    }
+    return {
+      backend: "agent-browser",
+      session,
+      connection,
+      connected,
+      error: error45,
+      agentBrowserVersion: getAgentPackageVersion()
+    };
+  }
+  return {
+    mode: "agent",
+    session,
+    connection,
+    getVersion: getAgentPackageVersion,
+    status,
+    requestTool
+  };
+}
+
+// src/plugin.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2 } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2 } from "path";
+import { spawn as spawn2 } from "child_process";
 import { fileURLToPath } from "url";
-console.log("[opencode-browser] Plugin loading...", { pid: process.pid });
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
-var PACKAGE_JSON_PATH = join(__dirname2, "..", "package.json");
+var PACKAGE_JSON_PATH = join2(__dirname2, "..", "package.json");
 var cachedVersion = null;
 function getPackageVersion() {
   if (cachedVersion)
     return cachedVersion;
   try {
-    const pkg = JSON.parse(readFileSync(PACKAGE_JSON_PATH, "utf8"));
+    const pkg = JSON.parse(readFileSync2(PACKAGE_JSON_PATH, "utf8"));
     if (typeof pkg?.version === "string") {
       cachedVersion = pkg.version;
       return cachedVersion;
@@ -12355,10 +13033,10 @@ function getPackageVersion() {
   return cachedVersion;
 }
 var { schema } = tool;
-var BASE_DIR = join(homedir(), ".opencode-browser");
-var SOCKET_PATH = join(BASE_DIR, "broker.sock");
+var BASE_DIR = join2(homedir(), ".opencode-browser");
+var SOCKET_PATH = join2(BASE_DIR, "broker.sock");
 mkdirSync(BASE_DIR, { recursive: true });
-function createJsonLineParser(onMessage) {
+function createJsonLineParser2(onMessage) {
   let buffer = "";
   return (chunk) => {
     buffer += chunk.toString("utf8");
@@ -12377,33 +13055,36 @@ function createJsonLineParser(onMessage) {
     }
   };
 }
-function writeJsonLine(socket, msg) {
+function writeJsonLine2(socket, msg) {
   socket.write(JSON.stringify(msg) + `
 `);
 }
 function maybeStartBroker() {
-  const brokerPath = join(BASE_DIR, "broker.cjs");
+  const brokerPath = join2(BASE_DIR, "broker.cjs");
   if (!existsSync(brokerPath))
     return;
   try {
-    const child = spawn(process.execPath, [brokerPath], { detached: true, stdio: "ignore" });
+    const child = spawn2(process.execPath, [brokerPath], { detached: true, stdio: "ignore" });
     child.unref();
   } catch {}
 }
 async function connectToBroker() {
   return await new Promise((resolve, reject) => {
-    const socket = net.createConnection(SOCKET_PATH);
+    const socket = net2.createConnection(SOCKET_PATH);
     socket.once("connect", () => resolve(socket));
     socket.once("error", (err) => reject(err));
   });
 }
-async function sleep(ms) {
+async function sleep2(ms) {
   return await new Promise((r) => setTimeout(r, ms));
 }
+var BACKEND_MODE = (process.env.OPENCODE_BROWSER_BACKEND ?? process.env.OPENCODE_BROWSER_MODE ?? "extension").toLowerCase().trim();
+var USE_AGENT_BACKEND = ["agent", "agent-browser", "agentbrowser"].includes(BACKEND_MODE);
 var socket = null;
 var sessionId = Math.random().toString(36).slice(2);
 var reqId = 0;
 var pending = new Map;
+var agentBackend = USE_AGENT_BACKEND ? createAgentBackend(sessionId) : null;
 async function ensureBrokerSocket() {
   if (socket && !socket.destroyed)
     return socket;
@@ -12412,7 +13093,7 @@ async function ensureBrokerSocket() {
   } catch {
     maybeStartBroker();
     for (let i = 0;i < 20; i++) {
-      await sleep(100);
+      await sleep2(100);
       try {
         socket = await connectToBroker();
         break;
@@ -12423,7 +13104,7 @@ async function ensureBrokerSocket() {
     throw new Error("Could not connect to local broker. Run `npx @different-ai/opencode-browser install` and ensure the extension is loaded.");
   }
   socket.setNoDelay(true);
-  socket.on("data", createJsonLineParser((msg) => {
+  socket.on("data", createJsonLineParser2((msg) => {
     if (msg?.type !== "response" || typeof msg.id !== "number")
       return;
     const p = pending.get(msg.id);
@@ -12442,7 +13123,7 @@ async function ensureBrokerSocket() {
   socket.on("error", () => {
     socket = null;
   });
-  writeJsonLine(socket, { type: "hello", role: "plugin", sessionId, pid: process.pid });
+  writeJsonLine2(socket, { type: "hello", role: "plugin", sessionId, pid: process.pid });
   return socket;
 }
 async function brokerRequest(op, payload) {
@@ -12450,7 +13131,7 @@ async function brokerRequest(op, payload) {
   const id = ++reqId;
   return await new Promise((resolve, reject) => {
     pending.set(id, { resolve, reject });
-    writeJsonLine(s, { type: "request", id, op, ...payload });
+    writeJsonLine2(s, { type: "request", id, op, ...payload });
     setTimeout(() => {
       if (!pending.has(id))
         return;
@@ -12459,6 +13140,12 @@ async function brokerRequest(op, payload) {
     }, 60000);
   });
 }
+async function brokerOnlyRequest(op, payload) {
+  if (USE_AGENT_BACKEND) {
+    throw new Error("Tab claims are not supported with agent-browser backend");
+  }
+  return await brokerRequest(op, payload);
+}
 function toolResultText(data, fallback) {
   if (typeof data?.content === "string")
     return data.content;
@@ -12468,8 +13155,29 @@ function toolResultText(data, fallback) {
     return JSON.stringify(data.content);
   return fallback;
 }
+async function toolRequest(toolName, args) {
+  if (USE_AGENT_BACKEND) {
+    if (!agentBackend) {
+      throw new Error("Agent backend unavailable: configuration failed to initialize");
+    }
+    return await agentBackend.requestTool(toolName, args);
+  }
+  return await brokerRequest("tool", { tool: toolName, args });
+}
+async function statusRequest() {
+  if (USE_AGENT_BACKEND) {
+    if (!agentBackend) {
+      return {
+        backend: "agent-browser",
+        connected: false,
+        error: "Agent backend unavailable: configuration failed to initialize"
+      };
+    }
+    return await agentBackend.status();
+  }
+  return await brokerRequest("status", {});
+}
 var plugin = async (ctx) => {
-  console.log("[opencode-browser] Plugin loading...", { pid: process.pid });
   return {
     tool: {
       browser_debug: tool({
@@ -12481,6 +13189,10 @@ var plugin = async (ctx) => {
             loaded: true,
             sessionId,
             pid: process.pid,
+            backend: USE_AGENT_BACKEND ? "agent-browser" : "extension",
+            agentSession: agentBackend?.session ?? null,
+            agentConnection: agentBackend?.connection ?? null,
+            agentBrowserVersion: agentBackend?.getVersion?.() ?? null,
             pluginVersion: getPackageVersion(),
             timestamp: new Date().toISOString()
           });
@@ -12494,15 +13206,17 @@ var plugin = async (ctx) => {
             name: "@different-ai/opencode-browser",
             version: getPackageVersion(),
             sessionId,
-            pid: process.pid
+            pid: process.pid,
+            backend: USE_AGENT_BACKEND ? "agent-browser" : "extension",
+            agentBrowserVersion: agentBackend?.getVersion?.() ?? null
           });
         }
       }),
       browser_status: tool({
-        description: "Check broker/native-host connection status and current tab claims.",
+        description: "Check backend connection status and current tab claims.",
         args: {},
         async execute(args, ctx2) {
-          const data = await brokerRequest("status", {});
+          const data = await statusRequest();
           return JSON.stringify(data);
         }
       }),
@@ -12510,10 +13224,39 @@ var plugin = async (ctx) => {
         description: "List all open browser tabs",
         args: {},
         async execute(args, ctx2) {
-          const data = await brokerRequest("tool", { tool: "get_tabs", args: {} });
+          const data = await toolRequest("get_tabs", {});
           return toolResultText(data, "ok");
         }
       }),
+      browser_list_claims: tool({
+        description: "List tab ownership claims",
+        args: {},
+        async execute(args, ctx2) {
+          const data = await brokerOnlyRequest("list_claims", {});
+          return JSON.stringify(data);
+        }
+      }),
+      browser_claim_tab: tool({
+        description: "Claim a browser tab for this session",
+        args: {
+          tabId: schema.number(),
+          force: schema.boolean().optional()
+        },
+        async execute({ tabId, force }, ctx2) {
+          const data = await brokerOnlyRequest("claim_tab", { tabId, force });
+          return JSON.stringify(data);
+        }
+      }),
+      browser_release_tab: tool({
+        description: "Release a claimed browser tab",
+        args: {
+          tabId: schema.number()
+        },
+        async execute({ tabId }, ctx2) {
+          const data = await brokerOnlyRequest("release_tab", { tabId });
+          return JSON.stringify(data);
+        }
+      }),
       browser_open_tab: tool({
         description: "Open a new browser tab",
         args: {
@@ -12521,7 +13264,7 @@ var plugin = async (ctx) => {
           active: schema.boolean().optional()
         },
         async execute({ url: url2, active }, ctx2) {
-          const data = await brokerRequest("tool", { tool: "open_tab", args: { url: url2, active } });
+          const data = await toolRequest("open_tab", { url: url2, active });
           return toolResultText(data, "Opened new tab");
         }
       }),
@@ -12532,7 +13275,7 @@ var plugin = async (ctx) => {
           tabId: schema.number().optional()
         },
         async execute({ url: url2, tabId }, ctx2) {
-          const data = await brokerRequest("tool", { tool: "navigate", args: { url: url2, tabId } });
+          const data = await toolRequest("navigate", { url: url2, tabId });
           return toolResultText(data, `Navigated to ${url2}`);
         }
       }),
@@ -12541,10 +13284,12 @@ var plugin = async (ctx) => {
         args: {
           selector: schema.string(),
           index: schema.number().optional(),
-          tabId: schema.number().optional()
+          tabId: schema.number().optional(),
+          timeoutMs: schema.number().optional(),
+          pollMs: schema.number().optional()
         },
-        async execute({ selector, index, tabId }, ctx2) {
-          const data = await brokerRequest("tool", { tool: "click", args: { selector, index, tabId } });
+        async execute({ selector, index, tabId, timeoutMs, pollMs }, ctx2) {
+          const data = await toolRequest("click", { selector, index, tabId, timeoutMs, pollMs });
           return toolResultText(data, `Clicked ${selector}`);
         }
       }),
@@ -12555,10 +13300,12 @@ var plugin = async (ctx) => {
           text: schema.string(),
           clear: schema.boolean().optional(),
           index: schema.number().optional(),
-          tabId: schema.number().optional()
+          tabId: schema.number().optional(),
+          timeoutMs: schema.number().optional(),
+          pollMs: schema.number().optional()
         },
-        async execute({ selector, text, clear, index, tabId }, ctx2) {
-          const data = await brokerRequest("tool", { tool: "type", args: { selector, text, clear, index, tabId } });
+        async execute({ selector, text, clear, index, tabId, timeoutMs, pollMs }, ctx2) {
+          const data = await toolRequest("type", { selector, text, clear, index, tabId, timeoutMs, pollMs });
           return toolResultText(data, `Typed "${text}" into ${selector}`);
         }
       }),
@@ -12570,13 +13317,12 @@ var plugin = async (ctx) => {
           label: schema.string().optional(),
           optionIndex: schema.number().optional(),
           index: schema.number().optional(),
-          tabId: schema.number().optional()
+          tabId: schema.number().optional(),
+          timeoutMs: schema.number().optional(),
+          pollMs: schema.number().optional()
         },
-        async execute({ selector, value, label, optionIndex, index, tabId }, ctx2) {
-          const data = await brokerRequest("tool", {
-            tool: "select",
-            args: { selector, value, label, optionIndex, index, tabId }
-          });
+        async execute({ selector, value, label, optionIndex, index, tabId, timeoutMs, pollMs }, ctx2) {
+          const data = await toolRequest("select", { selector, value, label, optionIndex, index, tabId, timeoutMs, pollMs });
           const summary = value ?? label ?? (optionIndex != null ? String(optionIndex) : "option");
           return toolResultText(data, `Selected ${summary} in ${selector}`);
         }
@@ -12587,7 +13333,7 @@ var plugin = async (ctx) => {
           tabId: schema.number().optional()
         },
         async execute({ tabId }, ctx2) {
-          const data = await brokerRequest("tool", { tool: "screenshot", args: { tabId } });
+          const data = await toolRequest("screenshot", { tabId });
           return toolResultText(data, "Screenshot failed");
         }
       }),
@@ -12597,7 +13343,7 @@ var plugin = async (ctx) => {
           tabId: schema.number().optional()
         },
         async execute({ tabId }, ctx2) {
-          const data = await brokerRequest("tool", { tool: "snapshot", args: { tabId } });
+          const data = await toolRequest("snapshot", { tabId });
           return toolResultText(data, "Snapshot failed");
         }
       }),
@@ -12607,10 +13353,12 @@ var plugin = async (ctx) => {
           selector: schema.string().optional(),
           x: schema.number().optional(),
           y: schema.number().optional(),
-          tabId: schema.number().optional()
+          tabId: schema.number().optional(),
+          timeoutMs: schema.number().optional(),
+          pollMs: schema.number().optional()
         },
-        async execute({ selector, x, y, tabId }, ctx2) {
-          const data = await brokerRequest("tool", { tool: "scroll", args: { selector, x, y, tabId } });
+        async execute({ selector, x, y, tabId, timeoutMs, pollMs }, ctx2) {
+          const data = await toolRequest("scroll", { selector, x, y, tabId, timeoutMs, pollMs });
           return toolResultText(data, "Scrolled");
         }
       }),
@@ -12621,7 +13369,7 @@ var plugin = async (ctx) => {
           tabId: schema.number().optional()
         },
         async execute({ ms, tabId }, ctx2) {
-          const data = await brokerRequest("tool", { tool: "wait", args: { ms, tabId } });
+          const data = await toolRequest("wait", { ms, tabId });
           return toolResultText(data, "Waited");
         }
       }),
@@ -12641,9 +13389,18 @@ var plugin = async (ctx) => {
           tabId: schema.number().optional()
         },
         async execute({ selector, mode, attribute, property, index, limit, timeoutMs, pollMs, pattern, flags, tabId }, ctx2) {
-          const data = await brokerRequest("tool", {
-            tool: "query",
-            args: { selector, mode, attribute, property, index, limit, timeoutMs, pollMs, pattern, flags, tabId }
+          const data = await toolRequest("query", {
+            selector,
+            mode,
+            attribute,
+            property,
+            index,
+            limit,
+            timeoutMs,
+            pollMs,
+            pattern,
+            flags,
+            tabId
           });
           return toolResultText(data, "Query failed");
         }