@different-ai/opencode-browser 4.4.0 → 4.5.1

package/.opencode/skill/github-release/SKILL.md

@@ -0,0 +1,12 @@
+---
+name: github-release
+description: Create a GitHub release after pnpm publish with clear feature updates.
+---
+
+Use this skill after running `pnpm publish`.
+
+1. Read the current version from `package.json` and set the tag name to `v<version>`.
+2. Summarize changes from git commits since the last tag, or if no tags exist, from the current conversation and latest commits.
+3. Draft release notes with a "## Features" section using those changes, and confirm with the user.
+4. Create the GitHub release with `gh release create v<version> --title "v<version>" --notes "<notes>"`.
+5. Confirm the release appears on GitHub and share the URL.

package/README.md

@@ -111,16 +111,22 @@ export OPENCODE_BROWSER_AGENT_PORT=9833
 
 ## Per-tab ownership
 
-- First time a session touches a tab, the broker **auto-claims** it for that session.
-- Other sessions attempting to use the same tab will get an error.
-- Use `browser_status` to inspect claims if needed.
+- Each session owns its own tabs; tabs are never shared between sessions.
+- If a session has no tab yet, the broker auto-creates a background tab on first tool use.
+- `browser_open_tab` always creates and claims a new tab for the session.
+- Claims expire after inactivity (`OPENCODE_BROWSER_CLAIM_TTL_MS`, default 5 minutes).
+- Use `browser_status` or `browser_list_claims` for debugging.
 
 ## Available tools
 
 Core primitives:
 - `browser_status`
 - `browser_get_tabs`
+- `browser_list_claims`
+- `browser_claim_tab`
+- `browser_release_tab`
 - `browser_open_tab`
+- `browser_close_tab`
 - `browser_navigate`
 - `browser_query` (modes: `text`, `value`, `list`, `exists`, `page_text`; optional `timeoutMs`/`pollMs`)
 - `browser_click` (optional `timeoutMs`/`pollMs`)
@@ -144,7 +150,7 @@ Diagnostics:
 
 ## Roadmap
 
-- [ ] Add tab management tools (`browser_set_active_tab`, `browser_close_tab`)
+- [ ] Add tab management tools (`browser_set_active_tab`)
 - [ ] Add navigation helpers (`browser_back`, `browser_forward`, `browser_reload`)
 - [ ] Add keyboard input tool (`browser_key`)
 - [ ] Add download support (`browser_download`, `browser_list_downloads`)
@@ -157,8 +163,9 @@ Diagnostics:
 - If you loaded a custom extension ID, rerun with `--extension-id <id>`
 
 **Tab ownership errors**
-- Use `browser_status` to see current claims
-- Close the other OpenCode session to release ownership
+- Errors usually mean you passed a `tabId` owned by another session
+- Use `browser_open_tab` to create a tab for your session (or omit `tabId` to use your default)
+- Use `browser_status` or `browser_list_claims` for debugging
 
 ## Uninstall
 

package/bin/broker.cjs

@@ -11,6 +11,20 @@ const SOCKET_PATH = path.join(BASE_DIR, "broker.sock");
 
 fs.mkdirSync(BASE_DIR, { recursive: true });
 
+const DEFAULT_LEASE_TTL_MS = 5 * 60 * 1000;
+const LEASE_TTL_MS = (() => {
+  const raw = process.env.OPENCODE_BROWSER_CLAIM_TTL_MS;
+  const value = Number(raw);
+  if (Number.isFinite(value) && value >= 0) return value;
+  return DEFAULT_LEASE_TTL_MS;
+})();
+const LEASE_SWEEP_MS =
+  LEASE_TTL_MS > 0 ? Math.min(Math.max(10000, Math.floor(LEASE_TTL_MS / 2)), 60000) : 0;
+
+function nowMs() {
+  return Date.now();
+}
+
 function nowIso() {
   return new Date().toISOString();
 }
@@ -39,7 +53,7 @@ function writeJsonLine(socket, msg) {
 }
 
 function wantsTab(toolName) {
-  return !["get_tabs", "get_active_tab"].includes(toolName);
+  return !["get_tabs", "get_active_tab", "open_tab"].includes(toolName);
 }
 
 // --- State ---
@@ -49,22 +63,78 @@ const extPending = new Map(); // extId -> { pluginSocket, pluginRequestId, sessi
 
 const clients = new Set();
 
-// Tab ownership: tabId -> { sessionId, claimedAt }
+// Tab ownership: tabId -> { sessionId, claimedAt, lastSeenAt }
 const claims = new Map();
+// Session state: sessionId -> { defaultTabId, lastSeenAt }
+const sessionState = new Map();
 
 function listClaims() {
   const out = [];
   for (const [tabId, info] of claims.entries()) {
-    out.push({ tabId, ...info });
+    out.push({
+      tabId,
+      sessionId: info.sessionId,
+      claimedAt: info.claimedAt,
+      lastSeenAt: new Date(info.lastSeenAt).toISOString(),
+    });
   }
   out.sort((a, b) => a.tabId - b.tabId);
   return out;
 }
 
+function sessionHasClaims(sessionId) {
+  for (const info of claims.values()) {
+    if (info.sessionId === sessionId) return true;
+  }
+  return false;
+}
+
+function getSessionState(sessionId) {
+  if (!sessionId) return null;
+  let state = sessionState.get(sessionId);
+  if (!state) {
+    state = { defaultTabId: null, lastSeenAt: nowMs() };
+    sessionState.set(sessionId, state);
+  }
+  return state;
+}
+
+function touchSession(sessionId) {
+  const state = getSessionState(sessionId);
+  if (!state) return null;
+  state.lastSeenAt = nowMs();
+  return state;
+}
+
+function setDefaultTab(sessionId, tabId) {
+  const state = getSessionState(sessionId);
+  if (!state) return;
+  state.defaultTabId = tabId;
+  state.lastSeenAt = nowMs();
+}
+
+function clearDefaultTab(sessionId, tabId) {
+  const state = sessionState.get(sessionId);
+  if (!state) return;
+  if (tabId === undefined || state.defaultTabId === tabId) {
+    state.defaultTabId = null;
+  }
+  state.lastSeenAt = nowMs();
+}
+
+function releaseClaim(tabId) {
+  const info = claims.get(tabId);
+  if (!info) return;
+  claims.delete(tabId);
+  clearDefaultTab(info.sessionId, tabId);
+}
+
 function releaseClaimsForSession(sessionId) {
   for (const [tabId, info] of claims.entries()) {
     if (info.sessionId === sessionId) claims.delete(tabId);
   }
+  clearDefaultTab(sessionId);
+  sessionState.delete(sessionId);
 }
 
 function checkClaim(tabId, sessionId) {
@@ -75,7 +145,37 @@ function checkClaim(tabId, sessionId) {
 }
 
 function setClaim(tabId, sessionId) {
-  claims.set(tabId, { sessionId, claimedAt: nowIso() });
+  const existing = claims.get(tabId);
+  claims.set(tabId, {
+    sessionId,
+    claimedAt: existing ? existing.claimedAt : nowIso(),
+    lastSeenAt: nowMs(),
+  });
+}
+
+function touchClaim(tabId, sessionId) {
+  const existing = claims.get(tabId);
+  if (existing && existing.sessionId !== sessionId) return;
+  if (existing) {
+    existing.lastSeenAt = nowMs();
+  } else {
+    setClaim(tabId, sessionId);
+  }
+}
+
+function cleanupStaleClaims() {
+  if (!LEASE_TTL_MS) return;
+  const now = nowMs();
+  for (const [tabId, info] of claims.entries()) {
+    if (now - info.lastSeenAt > LEASE_TTL_MS) {
+      releaseClaim(tabId);
+    }
+  }
+  for (const [sessionId, state] of sessionState.entries()) {
+    if (!sessionHasClaims(sessionId) && now - state.lastSeenAt > LEASE_TTL_MS) {
+      sessionState.delete(sessionId);
+    }
+  }
 }
 
 function ensureHost() {
@@ -106,10 +206,13 @@ function callExtension(tool, args, sessionId) {
   });
 }
 
-async function resolveActiveTab(sessionId) {
-  const res = await callExtension("get_active_tab", {}, sessionId);
+async function ensureSessionTab(sessionId) {
+  if (!sessionId) throw new Error("Missing sessionId for tab creation");
+  const res = await callExtension("open_tab", { active: false }, sessionId);
   const tabId = res && typeof res.tabId === "number" ? res.tabId : undefined;
-  if (!tabId) throw new Error("Could not determine active tab");
+  if (!tabId) throw new Error("Failed to create a new tab for this session");
+  touchClaim(tabId, sessionId);
+  setDefaultTab(sessionId, tabId);
   return tabId;
 }
 
@@ -117,25 +220,45 @@ async function handleTool(pluginSocket, req) {
   const { tool, args = {}, sessionId } = req;
   if (!tool) throw new Error("Missing tool");
 
+  if (sessionId) touchSession(sessionId);
+
   let tabId = args.tabId;
+  const toolArgs = { ...args };
+
+  const isCloseTool = tool === "close_tab";
 
   if (wantsTab(tool)) {
     if (typeof tabId !== "number") {
-      tabId = await resolveActiveTab(sessionId);
+      const state = getSessionState(sessionId);
+      const defaultTabId = state && Number.isFinite(state.defaultTabId) ? state.defaultTabId : null;
+      if (Number.isFinite(defaultTabId)) {
+        tabId = defaultTabId;
+      } else if (!isCloseTool) {
+        tabId = await ensureSessionTab(sessionId);
+      } else {
+        throw new Error("No tab owned by this session. Open a new tab first.");
+      }
     }
 
     const claimCheck = checkClaim(tabId, sessionId);
     if (!claimCheck.ok) throw new Error(claimCheck.error);
   }
 
-  const res = await callExtension(tool, { ...args, tabId }, sessionId);
+  const res = await callExtension(tool, { ...toolArgs, tabId }, sessionId);
 
   const usedTabId =
     res && typeof res.tabId === "number" ? res.tabId : typeof tabId === "number" ? tabId : undefined;
   if (typeof usedTabId === "number") {
-    // Auto-claim on first touch
-    const existing = claims.get(usedTabId);
-    if (!existing) setClaim(usedTabId, sessionId);
+    if (isCloseTool) {
+      if (claims.has(usedTabId)) {
+        releaseClaim(usedTabId);
+      } else {
+        clearDefaultTab(sessionId, usedTabId);
+      }
+    } else {
+      touchClaim(usedTabId, sessionId);
+      setDefaultTab(sessionId, usedTabId);
+    }
   }
 
   return res;
@@ -145,6 +268,7 @@ function handleClientMessage(socket, client, msg) {
   if (msg && msg.type === "hello") {
     client.role = msg.role || "unknown";
     client.sessionId = msg.sessionId;
+    if (client.sessionId) touchSession(client.sessionId);
     if (client.role === "native-host") {
       host = { socket };
       // allow host to see current state
@@ -174,6 +298,7 @@ function handleClientMessage(socket, client, msg) {
   if (msg && msg.type === "request" && typeof msg.id === "number") {
     const requestId = msg.id;
     const sessionId = msg.sessionId || client.sessionId;
+    if (sessionId) touchSession(sessionId);
 
     const replyOk = (data) => writeJsonLine(socket, { type: "response", id: requestId, ok: true, data });
     const replyErr = (err) =>
@@ -182,7 +307,21 @@ function handleClientMessage(socket, client, msg) {
     (async () => {
       try {
         if (msg.op === "status") {
-          replyOk({ broker: true, hostConnected: !!host && !!host.socket && !host.socket.destroyed, claims: listClaims() });
+          const state = sessionId ? sessionState.get(sessionId) : null;
+          const sessionInfo = state
+            ? {
+                sessionId,
+                defaultTabId: state.defaultTabId,
+                lastSeenAt: new Date(state.lastSeenAt).toISOString(),
+              }
+            : null;
+          replyOk({
+            broker: true,
+            hostConnected: !!host && !!host.socket && !host.socket.destroyed,
+            claims: listClaims(),
+            leaseTtlMs: LEASE_TTL_MS,
+            session: sessionInfo,
+          });
           return;
         }
 
@@ -199,7 +338,11 @@ function handleClientMessage(socket, client, msg) {
           if (existing && existing.sessionId !== sessionId && !force) {
             throw new Error(`Tab ${tabId} is owned by another OpenCode session (${existing.sessionId})`);
           }
+          if (existing && existing.sessionId !== sessionId && force) {
+            clearDefaultTab(existing.sessionId, tabId);
+          }
           setClaim(tabId, sessionId);
+          setDefaultTab(sessionId, tabId);
           replyOk({ ok: true, tabId, sessionId });
           return;
         }
@@ -215,7 +358,7 @@ function handleClientMessage(socket, client, msg) {
           if (existing.sessionId !== sessionId) {
             throw new Error(`Tab ${tabId} is owned by another OpenCode session (${existing.sessionId})`);
           }
-          claims.delete(tabId);
+          releaseClaim(tabId);
           replyOk({ ok: true, tabId, released: true });
           return;
         }
@@ -287,4 +430,9 @@ function start() {
   });
 }
 
+if (LEASE_TTL_MS > 0 && LEASE_SWEEP_MS > 0) {
+  const timer = setInterval(cleanupStaleClaims, LEASE_SWEEP_MS);
+  if (typeof timer.unref === "function") timer.unref();
+}
+
 start();

package/dist/plugin.js

@@ -12864,6 +12864,14 @@ function createAgentBackend(sessionId) {
         }
         return { content: { tabId: created.index, url: args.url, active: active !== false } };
       }
+      case "close_tab": {
+        const payload = {};
+        if (Number.isFinite(args.tabId))
+          payload.index = args.tabId;
+        const result = await agentCommand("tab_close", payload);
+        const closed = Number.isFinite(result?.closed) ? result.closed : args.tabId;
+        return { content: { tabId: closed, remaining: result?.remaining } };
+      }
       case "navigate": {
         return await withTab(args.tabId, async () => {
           if (!args.url)
@@ -13140,6 +13148,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;
@@ -13222,6 +13236,35 @@ var plugin = async (ctx) => {
           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: {
@@ -13233,6 +13276,16 @@ var plugin = async (ctx) => {
           return toolResultText(data, "Opened new tab");
         }
       }),
+      browser_close_tab: tool({
+        description: "Close a browser tab owned by this session",
+        args: {
+          tabId: schema.number().optional()
+        },
+        async execute({ tabId }, ctx2) {
+          const data = await toolRequest("close_tab", { tabId });
+          return toolResultText(data, "Closed tab");
+        }
+      }),
       browser_navigate: tool({
         description: "Navigate to a URL in the browser",
         args: {

package/extension/background.js

@@ -101,6 +101,7 @@ async function executeTool(toolName, args) {
     get_active_tab: toolGetActiveTab,
     get_tabs: toolGetTabs,
     open_tab: toolOpenTab,
+    close_tab: toolCloseTab,
     navigate: toolNavigate,
     click: toolClick,
     type: toolType,
@@ -709,6 +710,12 @@ async function toolOpenTab({ url, active = true }) {
   return { tabId: tab.id, content: { tabId: tab.id, url: tab.url, active: tab.active } }
 }
 
+async function toolCloseTab({ tabId }) {
+  if (!Number.isFinite(tabId)) throw new Error("tabId is required")
+  await chrome.tabs.remove(tabId)
+  return { tabId, content: { tabId, closed: true } }
+}
+
 async function toolNavigate({ url, tabId }) {
   if (!url) throw new Error("URL is required")
   const tab = await getTabById(tabId)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@different-ai/opencode-browser",
-  "version": "4.4.0",
+  "version": "4.5.1",
   "description": "Browser automation plugin for OpenCode (native messaging + per-tab ownership).",
   "type": "module",
   "bin": {
@@ -18,13 +18,6 @@
     "extension",
     "README.md"
   ],
-  "scripts": {
-    "build": "bun build src/plugin.ts --target=node --outfile=dist/plugin.js",
-    "install": "node bin/cli.js install",
-    "uninstall": "node bin/cli.js uninstall",
-    "status": "node bin/cli.js status",
-    "tool-test": "bun bin/tool-test.ts"
-  },
   "keywords": [
     "opencode",
     "browser",
@@ -52,5 +45,12 @@
   "devDependencies": {
     "@opencode-ai/plugin": "*",
     "bun-types": "*"
+  },
+  "scripts": {
+    "build": "bun build src/plugin.ts --target=node --outfile=dist/plugin.js",
+    "install": "node bin/cli.js install",
+    "uninstall": "node bin/cli.js uninstall",
+    "status": "node bin/cli.js status",
+    "tool-test": "bun bin/tool-test.ts"
   }
-}
+}