dsh-builtin-browser 0.4.9 → 0.4.10

package/src/browser-electron/system-browser.ts

@@ -82,6 +82,7 @@ const defaultLauncher: BrowserLauncher = (path, args) =>
 import { spawn, type ChildProcess } from 'node:child_process'
 import { randomUUID } from 'node:crypto'
 import type { ElectronBrowserViewHost, ElectronViewHandle } from './provider.js'
+import type { CarrierPage } from '../browser/types.js'
 
 /** Which browser the user asked for. */
 export type BrowserChannel = 'bundled' | 'chrome' | 'edge' | 'auto' | 'sidebar'
@@ -187,6 +188,19 @@ const INSTALL_LOCATIONS: Record<DetectedBrowser['kind'], Partial<Record<NodeJS.P
  * @param env - the environment to resolve against.
  * @returns the path with %NAME% references replaced, or the entry unchanged when unknown.
  */
+/**
+ * Whether a browser's self-reported product name is one this carrier could have launched.
+ *
+ * `edg`, not `edge`: Edge reports itself as `Edg/155.0.4283.45`, both over HTTP and over the
+ * protocol. Testing for the full word rejected a live Edge that had just been started, so the
+ * call failed with the hand-off error this check was added to prevent — while the browser was
+ * running the whole time, answering on its own port.
+ * @param product - the product string a browser reports about itself.
+ */
+function isBrowserProduct(product: unknown): boolean {
+  return typeof product === 'string' && /chrome|chromium|edg/i.test(product)
+}
+
 /**
  * Whether a target URL is one of the blanks a browser opens by itself.
  *
@@ -619,13 +633,13 @@ export class SystemBrowserViewHost implements ElectronBrowserViewHost {
       if (typeof version.webSocketDebuggerUrl !== 'string') return undefined
       // The port number alone proves nothing — it can be reused once the browser that owned it
       // exits. The endpoint's own answer is the evidence, and it has to name a browser.
-      if (typeof version.Browser !== 'string' || !/chrome|chromium|edge/i.test(version.Browser)) return undefined
+      if (!isBrowserProduct(version.Browser)) return undefined
       const client = new CdpClient(version.webSocketDebuggerUrl)
       await client.whenReady()
       // Asked through the protocol too, so a websocket that merely accepts connections is not
       // mistaken for a browser that answers.
       const info = await client.send('Browser.getVersion', {}) as { product?: string }
-      if (typeof info?.product !== 'string' || !/chrome|chromium|edge/i.test(info.product)) {
+      if (!isBrowserProduct(info?.product)) {
         client.close()
         return undefined
       }
@@ -867,6 +881,69 @@ export class SystemBrowserViewHost implements ElectronBrowserViewHost {
     return !this.disposed
   }
 
+  /**
+   * Every page the browser currently holds, including ones this plugin did not create.
+   *
+   * Chrome and Edge own their own page creation. A click on a link that opens a new page — or any
+   * `window.open` — produces a page the provider never asked for, and nothing reports it back.
+   * Those pages are real: they hold memory and stay until something closes them. Measured on a real
+   * window: four pages present while `dsh_browser_list_tabs` reported one.
+   *
+   * Discovery is already on at connection time (see the blank-page normalisation), so
+   * `Target.getTargets` also lists pages that existed before this client connected.
+   * @returns the browser's pages, or an empty list when it cannot answer.
+   */
+  /**
+   * Every page the browser holds that THIS HOST did not open.
+   *
+   * Chrome and Edge own their own page creation. A click on a link that opens a new page — or any
+   * `window.open` — produces a page the provider never asked for, and nothing reports it back.
+   * Those pages are real: they hold memory and stay until something closes them. Measured on a real
+   * window: four pages present while `dsh_browser_list_tabs` reported one.
+   *
+   * Pages this host opened are EXCLUDED here rather than deduplicated by the caller, because the
+   * caller cannot do it: the provider knows a tab by its own id, the carrier knows a page by its
+   * CDP target id, and the two never match. The first version returned everything and relied on the
+   * caller to filter, which reported the same page twice.
+   *
+   * Discovery is already on at connection time (see the blank-page normalisation), so
+   * `Target.getTargets` also lists pages that existed before this client connected.
+   * @returns the browser's pages that are not ours, or an empty list when it cannot answer.
+   */
+  async listPages(): Promise<readonly CarrierPage[]> {
+    try {
+      const client = await this.ensureClient()
+      const listed = await client.send('Target.getTargets', {}) as {
+        targetInfos?: Array<{ targetId?: string; type?: string; url?: string; title?: string }>
+      }
+      const ours = new Set(this.sessions.values())
+      return (listed?.targetInfos ?? [])
+        .filter(entry => entry.type === 'page' && typeof entry.targetId === 'string')
+        .filter(entry => !ours.has(entry.targetId as string))
+        .map(entry => ({
+          id: entry.targetId as string,
+          url: typeof entry.url === 'string' ? entry.url : '',
+          ...typeof entry.title === 'string' && entry.title !== '' ? { title: entry.title } : {},
+        }))
+    } catch {
+      // A listing must not fail harder than driving does; the next command reports a real problem.
+      return []
+    }
+  }
+
+  /**
+   * Close one page by the target id {@link listPages} reported.
+   *
+   * `Target.closeTarget` is the browser's own close, so it works for pages this plugin never
+   * created. The page may already be gone if the human closed it in the meantime — the caller
+   * asked for it to be closed and it is, so that is not an error.
+   * @param id - the CDP target id.
+   */
+  async closePage(id: string): Promise<void> {
+    const client = await this.ensureClient()
+    await client.send('Target.closeTarget', { targetId: id }).catch(() => undefined)
+  }
+
   createView(): ElectronViewHandle {
     const viewId = randomUUID()
     return {