dsh-builtin-browser 0.4.1 → 0.4.5

package/desktop-bridge/plugin-browser-bridge.js

@@ -48,6 +48,140 @@ function endpointFile() {
 /** One CDP command against a guest, serialized per guest. */
 const queues = new Map()
 
+/**
+ * Which owner holds which sidebar guest.
+ *
+ * The sidebar is a single surface shared by every DSH session, and each session runs in its own
+ * plugin process with its own in-memory view map. A session could therefore only see its OWN
+ * claims, and would adopt any tab it found — including one another session had opened. The
+ * symptom was a URL opened in one session appearing in another's sidebar, with the first
+ * session reporting failure.
+ *
+ * The ledger lives here because this process is the one that owns the sidebar, so it is the only
+ * place where "who holds what" can be a single shared fact. Owners are per-process ids supplied
+ * by the plugin; an entry is dropped when its guest disappears so a closed tab can be reused.
+ */
+const claims = new Map()
+
+/**
+ * When this module was loaded, and the protocol generation it speaks.
+ *
+ * The bridge is imported once by `main.js` at boot, so editing the file changes nothing until the
+ * host process restarts. That makes "did my restart actually load the new bridge?" a real question
+ * — and a run that cannot answer it will blame the new code for the old code's behaviour. The
+ * acceptance script compares this against the file's mtime and says so before testing anything.
+ */
+const LOADED_AT = new Date().toISOString()
+const PROTOCOL = 2
+
+/**
+ * The DOM root of THIS conversation's sidebar, as JavaScript to embed in a page script.
+ *
+ * The shell mounts one sidebar per conversation. Only one is on screen, but every conversation's
+ * panel is addressable — each carries its conversation id on the React fiber of its tab strip
+ * (measured on the running app: two containers, two ids). So an operation belongs to the panel of
+ * the conversation that asked, and NOT to whatever happens to be on screen.
+ *
+ * That distinction is the whole bug: driving "whatever is on screen" meant an operation issued
+ * while the human read another conversation typed into THAT conversation's address bar and
+ * navigated its page. Scoping every query to this root is what makes sessions unable to interfere
+ * with each other — there is no path from here to somebody else's panel.
+ *
+ * @param sessionId - the conversation this process serves (the request's `owner`).
+ * @returns an expression evaluating to the panel element, or null when there is none.
+ */
+function panelRootExpression(sessionId) {
+  return `(() => {
+    const sessionOf = (el) => {
+      const key = Object.keys(el).find(k => k.startsWith('__reactFiber$') || k.startsWith('__reactInternalInstance$'));
+      if (key === undefined) return null;
+      let fiber = el[key];
+      let depth = 0;
+      while (fiber !== null && fiber !== undefined && depth < 60) {
+        const props = fiber.memoizedProps;
+        if (props !== null && typeof props === 'object' && typeof props.sessionId === 'string') return props.sessionId;
+        fiber = fiber.return;
+        depth += 1;
+      }
+      return null;
+    };
+    const wanted = ${JSON.stringify(String(sessionId))};
+    const mine = Array.from(document.querySelectorAll('[class*=_tabStrip]')).find(el => sessionOf(el) === wanted);
+    if (mine === undefined) return null;
+    return mine.closest('[class*=_tabHost]') ?? mine.parentElement ?? mine;
+  })()`
+}
+
+/**
+ * Run a page script against THIS conversation's panel.
+ *
+ * Rather than editing ten DOM queries to use a different root — and leaving the eleventh to be
+ * forgotten — the document-level lookups are redirected for the duration of the script. Every
+ * existing query then answers from the right panel without knowing it, and a script that would
+ * have reached somebody else's panel finds nothing instead.
+ *
+ * The redirection is synchronous and restored in a `finally`, so React's own event handlers (which
+ * capture their references) are unaffected.
+ *
+ * @param shellId - the shell window's webContents id.
+ * @param expression - the page script to run.
+ * @param sessionId - the conversation this process serves.
+ * @returns the CDP answer, or a synthetic NO_PANEL verdict.
+ */
+async function evaluateInPanel(shellId, sessionId, method, params) {
+  // Only a real conversation id can be matched against the shell's panels. A host that could not
+  // supply one keeps the previous, unscoped behaviour: losing the scoping beats losing every DOM
+  // path, and the ownership guard treats such a host the same way.
+  if (typeof sessionId !== 'string' || !sessionId.startsWith('session-')) {
+    return sendCdp(shellId, method, params)
+  }
+  if (method !== 'Runtime.evaluate' || typeof params?.expression !== 'string') {
+    return sendCdp(shellId, method, params)
+  }
+  const body = params.expression
+  const script = `(() => {
+    const panel = ${panelRootExpression(sessionId)};
+    if (panel === null) return JSON.stringify({ noPanel: true });
+    const realQuery = document.querySelector.bind(document);
+    const realQueryAll = document.querySelectorAll.bind(document);
+    document.querySelector = (selector) => panel.querySelector(selector);
+    document.querySelectorAll = (selector) => panel.querySelectorAll(selector);
+    try {
+      return (${body});
+    } finally {
+      document.querySelector = realQuery;
+      document.querySelectorAll = realQueryAll;
+    }
+  })()`
+  const shell = guestById(shellId)
+  if (shell === undefined || shell.isDestroyed()) return { result: { value: 'NO_SHELL' } }
+  // `executeJavaScript`, for the same measured reason as `evaluatePanelService`: the debugger
+  // attachment to the shell WINDOW hangs while the same channel to a guest page answers at once.
+  // These calls are the same kind — one synchronous page script whose answer is a string — so none
+  // of them needs the protocol. The reply keeps the CDP shape because every caller reads
+  // `answer.result.value`.
+  let value
+  try {
+    value = await shell.executeJavaScript(script, true)
+  } catch (error) {
+    return { result: { value: '' } }
+  }
+  // `typeof` below already tolerates an absent value; the fallback keeps the shape explicit for
+  // the scanner in tests/bridge-reply-shape.test.mjs, which exists because a bare read of a reply
+  // once made a probe answer `undefined` forever.
+  const text = typeof value === 'string' ? value : ''
+  if (text.includes('"noPanel":true')) {
+    return { result: { value: 'NO_PANEL' } }
+  }
+  return { result: { value: text } }
+}
+
+/** Forget claims whose guest no longer exists, so a closed tab's id is not held forever. */
+function pruneClaims() {
+  const live = new Set(webContents.getAllWebContents().filter(c => c.getType() === 'webview').map(c => c.id))
+  for (const id of [...claims.keys()]) if (!live.has(id)) claims.delete(id)
+}
+
 function guestById(id) {
   for (const contents of webContents.getAllWebContents()) {
     if (contents.id === id) return contents
@@ -90,166 +224,254 @@ async function sendCdp(id, method, params) {
   return await next
 }
 
+/**
+ * Ask the shell's renderer for THIS conversation's browser panel, and report its guest.
+ *
+ * The renderer is the only side that knows which sidebar belongs to which conversation: the
+ * shell mounts one per conversation and keeps the DSH session id on each. The plugin's own
+ * client half carries that knowledge and publishes it as `globalThis.__dshBuiltinBrowser`; it
+ * calls the shell's `openTabIn(sessionId, …)`, which navigates BY CONVERSATION ID rather than
+ * by what the shell happens to be displaying.
+ *
+ * Nothing here inspects the DOM, dispatches a key, or clicks an element — it evaluates one call
+ * on a global the plugin itself published, and that global does the scoping internally.
+ *
+ * @param shellId - the shell window's webContents id.
+ * @param sessionId - the conversation that asked (the request's `owner`).
+ * @param url - address to load when a panel has to be opened; empty to only read.
+ * @returns the renderer's verdict, normalized so a malformed answer is a named failure.
+ */
+async function evaluatePanelService(shellId, sessionId, url) {
+  const expression = `(() => {
+    const api = globalThis.__dshBuiltinBrowser;
+    if (api === undefined || api === null || typeof api.openPanel !== 'function') {
+      return JSON.stringify({ ok: false, reason: 'the plugin client half is not loaded in this window' });
+    }
+    try {
+      return JSON.stringify(api.openPanel(${JSON.stringify(String(sessionId))}, ${JSON.stringify(String(url ?? ''))}));
+    } catch (error) {
+      return JSON.stringify({ ok: false, reason: String((error && error.message) || error) });
+    }
+  })()`
+  // `executeJavaScript`, NOT the debugger/CDP path.
+  //
+  // Measured on the running shell: the debugger attachment to the shell WINDOW is unreliable — its
+  // commands hang, repeatedly and for minutes, while the same channel to a guest page answers at
+  // once. Nothing here needs the protocol: it is one synchronous call on a global the plugin itself
+  // published. `executeJavaScript` reaches the page's main world directly, with no attachment to go
+  // stale and no reply to be lost. The guest path keeps CDP, because driving a PAGE genuinely needs
+  // it (`Runtime.evaluate`, `Page.*`, `Input.*`).
+  const shell = guestById(shellId)
+  if (shell === undefined || shell.isDestroyed()) {
+    return { ok: false, reason: 'the shell window is gone', panel: false, guestId: null, url: '' }
+  }
+  let value
+  try {
+    value = await shell.executeJavaScript(expression, true)
+  } catch (error) {
+    return {
+      ok: false,
+      reason: 'the shell refused the panel request: ' + String((error && error.message) || error),
+      panel: false,
+      guestId: null,
+      url: '',
+    }
+  }
+  if (typeof value !== 'string' || value === '') {
+    return { ok: false, reason: 'the shell did not answer the panel request', panel: false, guestId: null, url: '' }
+  }
+  try {
+    const parsed = JSON.parse(value)
+    return {
+      ok: parsed?.ok === true,
+      reason: parsed?.reason === undefined ? undefined : String(parsed.reason),
+      panel: parsed?.panel === true,
+      created: parsed?.created === true,
+      guestId: typeof parsed?.guestId === 'number' && Number.isFinite(parsed.guestId) ? parsed.guestId : null,
+      url: typeof parsed?.url === 'string' ? parsed.url : '',
+      // A refusal carries what the renderer found, so the reason is actionable rather than a guess.
+      found: parsed?.found === undefined ? undefined : parsed.found,
+    }
+  } catch (error) {
+    return { ok: false, reason: 'the shell answered a shape this bridge does not understand', panel: false, guestId: null, url: '' }
+  }
+}
+
+/** Whether a guest is already showing the requested address (so no navigation is needed). */
+function guestShows(id, url) {
+  if (url === '') return true
+  const guest = guestById(id)
+  if (guest === undefined) return false
+  try {
+    const current = guest.getURL()
+    return current !== '' && (current === url || current.startsWith(url))
+  } catch (error) {
+    return false
+  }
+}
+
 /** Handle one JSON request line; every answer is a JSON line too. */
 async function handle(request) {
   const op = String(request?.op ?? '')
+  // Who is asking. Declared once, for every op, because the first attempt at this put `owner` in
+  // the allocation path only and the reuse path — which every later call takes — stayed blind,
+  // so one session was handed another's page and counted another's tabs as its own.
+  const owner = typeof request?.owner === 'string' && request.owner !== '' ? request.owner : 'anonymous'
+  // Which build is answering. The acceptance script asks this first, because everything else it
+  // measures is meaningless if the host is still running the previous bridge.
+  if (op === 'version') {
+    return { ok: true, loadedAt: LOADED_AT, protocol: PROTOCOL }
+  }
   if (op === 'list') {
     const all = webContents.getAllWebContents().map(describe)
-    return { ok: true, guests: all, sidebar: all.filter(g => g.type === 'webview') }
+    // A guest claimed by another owner is not this caller's to see or to drive. Its id, url and
+    // title are that session's business; handing them over is how a session came to list pages it
+    // never opened. The shell window is always reported: it is what every op drives.
+    const mineOrFree = all.filter(g => g.type !== 'webview' || !claims.has(g.id) || claims.get(g.id) === owner)
+    return { ok: true, guests: mineOrFree, sidebar: mineOrFree.filter(g => g.type === 'webview') }
   }
   if (op === 'cdp') {
     const id = Number(request.id)
     if (!Number.isFinite(id)) throw new Error('cdp requires a numeric id')
     const result = await sendCdp(id, String(request.method ?? ''), request.params)
-    return { ok: true, result }
+    return { ok: true, result, bridgeRequestId: request.bridgeRequestId }
   }
   if (op === 'ensureSidebar') {
-    const url = request.url === undefined ? '' : String(request.url)
-    // Materialize a sidebar guest, optionally navigating it.
+    // This conversation's OWN panel, opened through the shell's own navigation — never by
+    // simulating input.
     //
-    // The sidebar browser creates its guest lazily: an un-navigated sidebar is
-    // only an address bar and owns no webContents at all, so "there is no guest"
-    // is the normal state rather than a failure. When one already exists this is
-    // a no-op; otherwise the shell's own UI is driven to open the right sidebar
-    // and submit an address — the same thing a human would do, and the only
-    // supported way to make the sidebar own a page.
-    const existing = webContents.getAllWebContents().filter(contents => contents.getType() === 'webview')
-    if (existing.length > 0) {
-      const first = existing[0]
-      if (request.url !== undefined && String(request.url) !== '') {
-        await sendCdp(first.id, 'Page.navigate', { url: String(request.url) })
-      }
-      return { ok: true, created: false, id: first.id }
-    }
+    // Every earlier version of this op drove the sidebar the way a human does: Ctrl+T, then a
+    // click on the 「浏览器」guide card, then typing into the address bar. All three land on the
+    // conversation the shell is DISPLAYING, because the shell routes keys and clicks to what it
+    // shows. So a page asked for while the human read another conversation was opened into THAT
+    // one, waiting for the screen to come back cost ten seconds, and when it never came back the
+    // retry loop left a tab per round. Three separate symptoms — "it opened in the wrong place",
+    // "it says it failed", "it opened a dozen browsers" — are one property of that path.
+    //
+    // The renderer can name the conversation instead. `openTabIn(sessionId, …)` is the shell's
+    // own navigation aimed at ONE conversation, and it does not read what is on screen at all —
+    // so this op no longer has an opinion about which conversation is displayed, and there is no
+    // path from here to somebody else's sidebar. DOM is not touched: the call is evaluated on the
+    // global the plugin's own client half published.
+    const url = request.url === undefined ? '' : String(request.url)
     const shell = webContents.getAllWebContents().find(contents => contents.getType() === 'window')
     if (shell === undefined) throw new Error('no shell window to drive')
-    // 1. Open the sidebar and put the caret in its address field IF that field is
-    //    reachable. It is not always: the sidebar may show another panel, or the
-    //    browser tab may be present but not active, in which case no address input
-    //    exists in the document at all. That must not be fatal — the restore route
-    //    below needs no address bar, and treating "no input" as a hard error is
-    //    exactly what made the first call after a restart fail.
-    const prepared = await sendCdp(shell.id, 'Runtime.evaluate', {
-      expression: shellPrepareSidebar(),
-      returnByValue: true,
-    })
-    const verdict = String(prepared?.result?.value ?? '')
-    // 2. Materialize a guest. Two routes, cheapest first:
-    //    a. the sidebar's own "restore last page" affordance — it navigates
-    //       without depending on how the address field handles focus or input;
-    //    b. otherwise type into the address field and submit with REAL key input
-    //       (synthetic events do not move React's controlled input, and the field
-    //       also loses focus to re-renders, so both halves are needed).
-    let submitVerdict = 'n/a'
-    const restored = await sendCdp(shell.id, 'Runtime.evaluate', {
-      // Only real controls count, and only their OWN text does. Matching any
-      // node's `textContent` made a container that merely mentioned restoring a
-      // page report RESTORED — which skipped the address route below entirely
-      // and left the guest unmaterialized (measured on DSH 0.2.0-rc.2, where the
-      // sidebar shows no restore control at all).
-      expression: `(() => {
-        const nodes = Array.from(document.querySelectorAll('button,a,[role=button],div[role=link]'));
-        const hit = nodes.find(n => {
-          const own = (n.textContent || '').trim();
-          if (own.length > 24) return false;
-          return /^(恢复页面|恢复上次|恢复上次页面|上次打开)$/.test(own)
-            || /恢复|restore/i.test(n.getAttribute('aria-label') || n.getAttribute('title') || '');
-        });
-        if (hit === undefined) return 'NO_RESTORE';
-        hit.click();
-        return 'RESTORED';
-      })()`,
-      returnByValue: true,
-    })
-    if (restored?.result?.value !== 'RESTORED') {
-      if (url !== '') {
-        // Set the value the way React accepts it, then SUBMIT THE FORM.
-        //
-        // A dispatched Enter is not enough: the sidebar browser's toolbar is a
-        // `<form>` whose submission is wired to an explicit control (aria-label
-        // "前往" / "Go"), and implicit submission does not fire there — measured
-        // on DSH 0.2.0-rc.2, where Enter left the field filled and the guest
-        // uncreated. `requestSubmit()` goes through the same path the button
-        // does, so it works with React's onSubmit and needs no localized label.
-        const typed = await sendCdp(shell.id, 'Runtime.evaluate', {
-          expression: `(() => {
-            const inputs = Array.from(document.querySelectorAll('input')).filter(i => /HTTP|地址|url/i.test((i.placeholder || '') + (i.getAttribute('aria-label') || '')));
-            if (inputs.length === 0) return 'NO_ADDRESS_BAR';
-            const input = inputs[inputs.length - 1];
-            const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value').set;
-            setter.call(input, ${JSON.stringify(String(request.url ?? ''))});
-            input.dispatchEvent(new Event('input', { bubbles: true }));
-            input.focus();
-            const form = input.form ?? input.closest('form');
-            if (form) { form.requestSubmit(); return 'SUBMITTED_FORM'; }
-            const button = input.parentElement
-              ? input.parentElement.querySelector('button[type=submit],button')
-              : null;
-            if (button) { button.click(); return 'CLICKED_SUBMIT'; }
-            return 'TYPED_ONLY';
-          })()`,
-          returnByValue: true,
-        })
-        submitVerdict = String(typed?.result?.value ?? 'n/a')
-        // Enter stays as the last resort for sidebars without a form.
-        if (submitVerdict === 'TYPED_ONLY') {
-          for (const type of ['keyDown', 'keyUp']) {
-            await sendCdp(shell.id, 'Input.dispatchKeyEvent', {
-              type,
-              key: 'Enter',
-              code: 'Enter',
-              windowsVirtualKeyCode: 13,
-              nativeVirtualKeyCode: 13,
-            })
-          }
-        }
+    if (!/^session-/.test(owner)) {
+      throw new Error('this host supplied no conversation id, so its own panel cannot be identified')
+    }
+
+    const ask = async (withUrl) => {
+      const answer = await evaluatePanelService(shell.id, owner, withUrl ? url : '')
+      if (answer.ok !== true) {
+        // Carry the renderer's own findings into the failure: it is the side that can see why the
+        // lookup missed, and a bare "not mounted" leaves the next reader guessing between a real
+        // absence and a lookup that reads the wrong place.
+        const detail = answer.found === undefined ? '' : ' — renderer found ' + JSON.stringify(answer.found)
+        throw new Error(String(answer.reason) + detail)
       }
+      return answer
     }
-    // The guest attaches asynchronously once the renderer creates the webview.
-    for (let attempt = 0; attempt < 24; attempt++) {
-      await new Promise(resolve => setTimeout(resolve, 500))
-      const created = webContents.getAllWebContents().filter(contents => contents.getType() === 'webview')
-      if (created.length > 0) {
-        // Now that a guest exists, navigation is a plain CDP call: no UI involved.
-        if (url !== '') {
-          await sendCdp(created[0].id, 'Page.navigate', { url }).catch(() => undefined)
-        }
-        return { ok: true, created: true, id: created[0].id, via: restored?.result?.value === 'RESTORED' ? 'restore' : 'address' }
+
+    // Already has a page: reuse it. This is the common case after the first open of a session.
+    const first = await ask(url !== '')
+    if (first.guestId !== null) {
+      claims.set(first.guestId, owner)
+      if (!guestShows(first.guestId, url)) {
+        await sendCdp(first.guestId, 'Page.navigate', { url }).catch(() => undefined)
       }
+      return { ok: true, created: false, id: first.guestId, via: 'panel', owner }
     }
-    throw new Error(`the sidebar did not create a browser guest (prepare=${String(verdict)}, restore=${String(restored?.result?.value)}, submit=${submitVerdict})`)
+
+    // A tab was placed, but this conversation is not the one the shell is displaying.
+    //
+    // The shell renders the sidebar of the conversation it SHOWS. A background conversation's panel
+    // exists in its own surface store — which is exactly why the tab could be placed at all — but
+    // it has no DOM, so no webview attaches and no amount of waiting would produce one. Waiting
+    // would turn a true statement into a timeout, and the page is genuinely there: it appears the
+    // moment the conversation is shown.
+    if (first.panel === false) {
+      throw new Error(
+        'a panel was placed in this conversation\'s sidebar, but its page can only attach while the '
+        + 'conversation is the one displayed — show it and the page appears',
+      )
+    }
+
+    // A guest attaches asynchronously once the renderer creates the webview. Poll INSIDE this
+    // conversation's panel, so a guest appearing in any other conversation cannot satisfy the wait
+    // — the scoping is what makes the wait safe.
+    const deadline = Date.now() + (url === '' ? 4_000 : 20_000)
+    while (Date.now() < deadline) {
+      await new Promise(resolve => setTimeout(resolve, 250))
+      const polled = await ask(false)
+      if (polled.guestId === null) continue
+      claims.set(polled.guestId, owner)
+      if (!guestShows(polled.guestId, url)) {
+        await sendCdp(polled.guestId, 'Page.navigate', { url }).catch(() => undefined)
+      }
+      return { ok: true, created: true, id: polled.guestId, via: 'panel', owner }
+    }
+    throw new Error(
+      'this conversation\'s browser panel produced no page within its budget '
+      + '(the shell placed no guest in this conversation\'s own sidebar)',
+    )
   }
-  if (op === 'ensureTabs') {
-    // Grow the sidebar's browser tab strip to `count` tabs and report every guest.
+  if (op === 'showTab') {
+    // Bring one browser guest to the front — the "switch to this tab" half of opening a page.
+    //
+    // Without this the desktop bridge had no way to satisfy `showView`, so its host
+    // implementation was an empty method and a newly opened page stayed behind whatever the
+    // human was looking at. Reported as issue #23; the other two carriers already did this
+    // (the self-hosted window re-adds the view, the system browser calls Page.bringToFront).
     //
-    // Tabs are the renderer's, so this cannot create them directly — it drives the
-    // sidebar's own "new tab" control, the same affordance a human uses, and then
-    // reports the guest ids. Whatever already exists is reused, so repeated calls
-    // are cheap and a human-opened tab is never orphaned.
-    const want = Math.max(1, Math.min(8, Number(request.count ?? 1)))
+    // The tab belongs to the renderer, so the same reasoning as `ensureTabs` applies: drive the
+    // sidebar's own control. A tab is matched by the title it shows, which is what the sidebar
+    // renders from the guest — the guest's id is not exposed in the DOM.
+    const viewId = Number(request.viewId)
+    if (!Number.isFinite(viewId)) throw new Error('showTab needs a viewId')
+    const guest = webContents.fromId(viewId)
+    if (guest === undefined) throw new Error(`showTab: no guest with id ${viewId}`)
+    // Only a guest this caller holds may be brought forward. Without the check, one session could
+    // switch the sidebar to another session's page — moving the human's view out from under it.
+    pruneClaims()
+    if (claims.has(viewId) && claims.get(viewId) !== owner) {
+      throw new Error(`showTab: guest ${viewId} belongs to another session`)
+    }
+    claims.set(viewId, owner)
     const shell = webContents.getAllWebContents().find(contents => contents.getType() === 'window')
     if (shell === undefined) throw new Error('no shell window to drive')
-    let lastVerdict = ''
-    for (let attempt = 0; attempt < 30; attempt++) {
-      const guests = webContents.getAllWebContents().filter(contents => contents.getType() === 'webview')
-      if (guests.length >= want) return { ok: true, ids: guests.map(contents => contents.id), verdict: lastVerdict }
-      const clicked = await sendCdp(shell.id, 'Runtime.evaluate', {
-        expression: `(() => {
-          const nodes = Array.from(document.querySelectorAll('button,[role=button]'));
-          const hit = nodes.find(b => /新标签页|新建标签|new tab/i.test((b.getAttribute('aria-label') || '') + (b.textContent || '') + (b.getAttribute('title') || '')));
-          if (hit === undefined) return 'NO_NEW_TAB_CONTROL';
-          hit.click();
-          return 'CLICKED';
-        })()`,
-        returnByValue: true,
-      })
-      lastVerdict = String(clicked?.result?.value ?? '')
-      if (lastVerdict === 'NO_NEW_TAB_CONTROL') {
-        throw new Error('the sidebar exposes no new-tab control (is the browser tab open?)')
-      }
-      await new Promise(resolve => setTimeout(resolve, 600))
+    const wantTitle = String(guest.getTitle() ?? '').trim()
+    const clicked = await evaluateInPanel(shell.id, owner, 'Runtime.evaluate', {
+      expression: `(() => {
+        const scan = (root, out) => {
+          for (const node of root.querySelectorAll('button,[role=button],[role=tab],a')) {
+            out.push(node);
+            if (node.shadowRoot) scan(node.shadowRoot, out);
+          }
+          return out;
+        };
+        const nodes = scan(document, []);
+        for (const frame of Array.from(document.querySelectorAll('iframe'))) {
+          try { if (frame.contentDocument) scan(frame.contentDocument, nodes) } catch { /* cross-origin */ }
+        }
+        const label = (n) => ((n.getAttribute('aria-label') || '') + ' ' + (n.textContent || '') + ' ' + (n.getAttribute('title') || '')).trim();
+        const want = ${JSON.stringify(wantTitle)};
+        // Exact title first, then the tab-like control whose label contains it: a strip may
+        // decorate the label with a close button, and a prefix match would hit the wrong tab
+        // when one title contains another.
+        let hit = nodes.find(n => want !== '' && label(n) === want);
+        if (hit === undefined) hit = nodes.find(n => want !== '' && label(n).includes(want) && /tab|page|标签/i.test(n.getAttribute('role') || n.className || ''));
+        if (hit === undefined) hit = nodes.find(n => want !== '' && label(n).includes(want));
+        if (hit === undefined) return 'NO_TAB_FOR_TITLE';
+        hit.click();
+        return 'CLICKED';
+      })()`,
+      returnByValue: true,
+    })
+    const verdict = String(clicked?.result?.value ?? '')
+    if (verdict !== 'CLICKED') {
+      throw new Error(`could not bring the page to the front (${verdict}; wanted "${wantTitle}")`)
     }
-    throw new Error(`the sidebar stopped at fewer than ${want} tabs`)
+    return { ok: true, verdict }
   }
   if (op === 'closeSidebarBrowser') {
     // Release the sidebar's browser pages by closing the tabs that host them.
@@ -264,8 +486,19 @@ async function handle(request) {
     // ending one session must not tear down another's page. With no titles given the
     // call means "release everything", which is only appropriate when the caller
     // knows it owns them all.
+    //
+    // The comment above said that; the code below did not enforce it. It closed every webview
+    // whose title matched — and with no filter, EVERY webview — regardless of which session held
+    // it. So one session's `browser_reset_session` could destroy another session's page, which is
+    // the worst version of the bleed: not merely seeing someone else's tab, but closing it.
+    //
+    // Ownership is now the outer bound: only guests this owner holds are candidates at all, and
+    // the title filter narrows further within them.
+    pruneClaims()
     const wanted = Array.isArray(request.titles) ? request.titles.map(title => String(title).slice(0, 24)).filter(title => title !== '') : undefined
-    const guests = webContents.getAllWebContents().filter(contents => contents.getType() === 'webview')
+    const guests = webContents.getAllWebContents()
+      .filter(contents => contents.getType() === 'webview')
+      .filter(contents => claims.get(contents.id) === owner)
     const titles = []
     for (const guest of guests) {
       try {
@@ -281,7 +514,7 @@ async function handle(request) {
     const shell = webContents.getAllWebContents().find(contents => contents.getType() === 'window')
     if (shell === undefined) throw new Error('no shell window to drive')
     if (titles.length === 0 && wanted !== undefined) return { ok: true, closed: 0 }
-    const clicked = await sendCdp(shell.id, 'Runtime.evaluate', {
+    const clicked = await evaluateInPanel(shell.id, owner, 'Runtime.evaluate', {
       expression: `(() => {
         const wanted = ${JSON.stringify(titles.map(title => title.slice(0, 24)))};
         let closed = 0;
@@ -304,7 +537,7 @@ async function handle(request) {
     // guest keeps running — collapsing is presentation, exactly as §3 asks.
     const shell = webContents.getAllWebContents().find(contents => contents.getType() === 'window')
     if (shell === undefined) throw new Error('no shell window to drive')
-    const folded = await sendCdp(shell.id, 'Runtime.evaluate', {
+    const folded = await evaluateInPanel(shell.id, owner, 'Runtime.evaluate', {
       expression: `(() => {
         const button = Array.from(document.querySelectorAll('button')).find(b => /收起右侧边栏/.test((b.getAttribute('aria-label') || '') + (b.textContent || '')));
         if (button === undefined) return 'NOT_OPEN';
@@ -313,32 +546,11 @@ async function handle(request) {
       })()`,
       returnByValue: true,
     })
-    return { ok: true, result: folded?.result?.value }
+    return { ok: true, result: folded?.result?.value, bridgeRequestId: request.bridgeRequestId }
   }
   throw new Error(`unknown op ${JSON.stringify(op)}`)
 }
 
-/**
- * In-page script that opens the right sidebar and focuses its address field.
- *
- * Only preparation happens here; the address itself is typed with real input
- * (see `ensureSidebar`), because a controlled React input ignores text assigned
- * through synthetic events.
- * @returns a self-contained expression evaluating to a short verdict string.
- */
-function shellPrepareSidebar() {
-  return `(() => {
-    const labelOf = el => ((el.getAttribute && el.getAttribute('aria-label')) || el.textContent || '').trim();
-    let opened = false;
-    for (const button of Array.from(document.querySelectorAll('button'))) {
-      if (/打开右侧边栏|右侧边栏/.test(labelOf(button))) { button.click(); opened = true; break; }
-    }
-    const inputs = Array.from(document.querySelectorAll('input')).filter(i => /HTTP|地址|url/i.test((i.placeholder || '') + (i.getAttribute('aria-label') || '')));
-    if (inputs.length === 0) return 'NO_ADDRESS_BAR:' + JSON.stringify(Array.from(document.querySelectorAll('input')).map(i => i.placeholder).slice(0, 6));
-    inputs[inputs.length - 1].focus();
-    return opened ? 'OPENED_AND_FOCUSED' : 'FOCUSED';
-  })()`
-}
 
 /**
  * Publish the endpoint, and keep it published.
@@ -369,8 +581,48 @@ function publishEndpoint(port, token) {
   }
 }
 
+/**
+ * The running bridge instance, keyed on globalThis so it survives a reload.
+ *
+ * A cache-busted re-import evaluates a FRESH module instance with its own
+ * module-level state. A plain module-scoped variable would therefore leave the
+ * previous bridge running: two keepalives would alternate writing the endpoint
+ * file and hand clients a port that is already closed. Symbol.for keeps the key
+ * identical across every instance of this module.
+ */
+const ACTIVE = Symbol.for("dsh-builtin-browser.bridge.active")
+
+/**
+ * Stop the running bridge: clears its keepalive timer, closes its listener and
+ * drops its quit hook. Idempotent and never throws, so the shell can call it
+ * before re-importing an edited bridge.
+ */
+export function stop() {
+  const current = globalThis[ACTIVE]
+  globalThis[ACTIVE] = undefined
+  if (!current) return
+  try { clearInterval(current.keepalive) } catch { /* ignore */ }
+  try { current.server.close() } catch { /* already closed */ }
+  try { app.off('will-quit', current.onQuit) } catch { /* ignore */ }
+}
+
 /** Start the bridge: loopback listener + published endpoint file + token. */
 export function start() {
+  stop()
+  // Drop any debugger attachment this process is still holding.
+  //
+  // An attachment belongs to the webContents, not to this module, so it outlives both the listener
+  // and the reload `main.js` performs when the file changes. A stale one is the worst kind of
+  // broken: `isAttached()` answers true, so the next bridge skips its own attach, and every command
+  // sent into it hangs — no error, no reply, nothing to see. A bridge that has JUST started has no
+  // attachments of its own, which makes whatever is attached right now a leftover: safe to drop,
+  // and exact. (If DevTools happens to be open on the shell it loses that session; the shell itself
+  // is unaffected, and that is the cheaper cost.)
+  try {
+    for (const contents of webContents.getAllWebContents()) {
+      try { if (contents.debugger.isAttached()) contents.debugger.detach() } catch { /* gone */ }
+    }
+  } catch { /* no webContents at all; nothing to detach */ }
   const token = randomBytes(24).toString('hex')
   const server = createServer(socket => {
     let buffer = ''
@@ -394,8 +646,16 @@ export function start() {
           if (typeof request.op !== 'string' || request.op === '') continue
         }
         void handle(request)
-          .then(answer => socket.write(JSON.stringify(answer) + '\n'))
-          .catch(error => socket.write(JSON.stringify({ ok: false, error: String(error?.message ?? error) }) + '\n'))
+          // The request id is stamped HERE, at the single point where every answer is written,
+          // rather than on the handful of returns that happened to remember it.
+          //
+          // The parent matches replies to requests by this id; when it is missing the parent
+          // marks the whole connection id-less and serialisable, which drops every reply back
+          // to arrival order and makes it reject in-flight requests when a second call
+          // arrives. Only two of this bridge's nine reply paths carried the field, so most
+          // operations permanently degraded the connection they used.
+          .then(answer => socket.write(JSON.stringify({ ...answer, bridgeRequestId: request.bridgeRequestId }) + '\n'))
+          .catch(error => socket.write(JSON.stringify({ ok: false, error: String(error?.message ?? error), bridgeRequestId: request.bridgeRequestId }) + '\n'))
       }
     })
     socket.on('error', () => { /* client went away */ })
@@ -417,9 +677,8 @@ export function start() {
     if (port !== 0) publishEndpoint(port, token)
   }, 15_000)
   keepalive.unref?.()
-  app.on('will-quit', () => {
-    clearInterval(keepalive)
-    try { server.close() } catch { /* already closed */ }
-  })
+  const onQuit = () => stop()
+  app.on('will-quit', onQuit)
+  globalThis[ACTIVE] = { server, keepalive, onQuit }
   return server
 }