dsh-inner-browser-use 0.34.99 → 0.35.1

package/client.js

@@ -355,10 +355,27 @@ window.__ModuleLoader__.load({
             }
           }
           restore()
+          /* A pane whose page the browser reclaimed is closed once, so coming
+             back to the chat does not bring the empty column back. */
+          const dropExpired = () => {
+            const who = mountedOf()
+            if (who === '' || hasPane(who) !== true) return
+            void fetch(`${ROUTE}/sidecar/state?session=${encodeURIComponent(who)}`) // ui-copy-ignore
+              .then((said) => (said.ok === true ? said.json() : null))
+              .then((state) => {
+                if (state?.chat?.expired !== true) return
+                if (mountedOf() !== who) return
+                closeHere(who, false)
+              })
+              .catch(() => {})
+          }
           const offAsk = watchAsk()
+          let beats = 0
           const pollAsk = setInterval(() => {
             syncAsk()
             watchPane()
+            beats += 1
+            if (beats % 5 === 1) dropExpired()
           }, 1000)
           const stopAsk = () => {
             clearInterval(pollAsk)
@@ -674,15 +691,11 @@ window.__ModuleLoader__.load({
         /* The page already has that shape: a resize that lands between two
            viewport sizes would only cost a relayout and another frame. */
         if (Math.abs(Number(view?.w ?? 0) - size.w) < 1 && Math.abs(Number(view?.h ?? 0) - size.h) < 1) return undefined
-        /* The page is told the column's size a beat after the resize stops, and
-           again until the browser says it took it: a request that arrives while
-           the page is still starting is refused, and a pane that gives up then
-           keeps a letterboxed picture for as long as it stays open. */
-        let live = true
-        let tries = 0
-        let timer = 0
-        const send = () => {
-          if (!live) return
+        /* The page is told the column's size a beat after the resize stops.
+           One ask: the pane draws at whatever shape the frame says it has, so
+           a browser that is still starting costs nothing more than the next
+           resize doing the same thing again. */
+        const timer = setTimeout(() => {
           fetch(`${ROUTE}/sidecar/viewport`, {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
@@ -690,30 +703,17 @@ window.__ModuleLoader__.load({
           })
             .then((answer) => (answer.ok === true ? answer.json() : { ok: false }))
             .then((said) => {
-              if (!live) return
               /* The browser answers with the shape it actually took: drawing
                  the picture at that size fills the pane even when the page
                  refused the exact one asked for. */
               const took = said?.view ?? null
               if (said?.ok === true && took !== null && Number(took.width) > 0 && Number(took.height) > 0) {
                 setView({ w: Math.round(Number(took.width)), h: Math.round(Number(took.height)) })
-                return
               }
-              if (said?.ok === true || tries >= 5) return
-              tries += 1
-              timer = setTimeout(send, 400)
-            })
-            .catch(() => {
-              if (!live || tries >= 5) return
-              tries += 1
-              timer = setTimeout(send, 600)
             })
-        }
-        timer = setTimeout(send, 250)
-        return () => {
-          live = false
-          clearTimeout(timer)
-        }
+            .catch(() => {})
+        }, 250)
+        return () => clearTimeout(timer)
       }, [mine, size.w, size.h, view?.w, view?.h])
 
       const who = String(props.sessionId ?? '')

package/index.js

@@ -280,6 +280,9 @@ export function cwdOf(execution) {
 
 export function needsTab(chatState, chat, owner) {
   if (String(chat ?? '') === '' || owner !== chat) return false
+  /* A tab the browser reclaimed is not a tab that went missing: opening one
+     again would bring back the column the person no longer needs. */
+  if (chatState?.expired === true) return false
   return chatState?.alive !== true
 }
 
@@ -521,7 +524,7 @@ export function apply(ctx) {
          called open again: the mirror would come back empty in a chat that
          never closed it. The chat that owned the browser asks for its state, so
          answering honestly means picking the browser up first. */
-      if (shouldAdoptOnState(said, chat, bridge.owner)) {
+      if (shouldAdoptOnState(said, chat, bridge.owner) && mineChat?.expired !== true) {
         try {
           await sidecar.ensure(adoptOptions(chat, sidecar.rememberedTab?.(chat)))
           said = await sidecar.state()
@@ -737,8 +740,8 @@ export function apply(ctx) {
       const who = acting(body)
       if (who === '') return
       const forgot = bridge.forget(who)
-      /* Nobody is watching a picture the person just closed: the browser itself
-         is put away a minute later rather than a quarter of an hour, unless an
+      /* Nobody is watching a picture the person closed: the browser itself is
+         put away a minute later rather than a quarter of an hour, unless an
          agent asks for it again in the meantime. */
       try {
         if (sidecar.watched() === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-inner-browser-use",
-  "version": "0.34.99",
+  "version": "0.35.1",
   "description": "An agent-owned Chromium sidecar mirrored into the DeepSeek Harness right column: the agent drives it, the person watches and can take the mouse, and logins survive restarts.",
   "type": "module",
   "main": "index.js",

package/sidecar.js

@@ -78,7 +78,7 @@ const QUALITY_FLOOR = 44 // ui-copy-ignore
 const QUALITY_CEILING = 76 // ui-copy-ignore
 
 /**
- * Decide the next JPEG quality from the weight of the frame just seen. A frame
+ * Decide the next JPEG quality from the weight of the frame seen. A frame
  * near 90 KB of base64 is a heavy page: lowering quality by 8 costs a little
  * sharpness and saves a lot of transport. A small frame has room to sharpen.
  * @param {number} current - quality now.
@@ -478,6 +478,30 @@ class Cdp {
  * Input is real CDP input: the page sees the same events a person's trackpad
  * produces, which is what makes sites that reject scripted clicks work.
  */
+/**
+ * Whether two addresses show the same place: a fragment never changes the page.
+ * @param {string} a - one address.
+ * @param {string} b - another address.
+ * @returns {string} the shared key, or '' when they differ.
+ */
+function placeKey(value) {
+  const said = String(value ?? '')
+  if (said === '') return ''
+  try {
+    const url = new URL(said)
+    url.hash = ''
+    const path = url.pathname.replace(/\/+$/, '') || '/'
+    return `${url.protocol}//${url.host}${path}${url.search}`
+  } catch {
+    return said
+  }
+}
+
+function samePlace(a, b) {
+  const key = placeKey(a)
+  return key !== '' && key === placeKey(b)
+}
+
 export class SidecarPage {
   /** @param {Cdp} cdp - the page session. @param {string} profile - profile name. */
   constructor(cdp, profile, port, hold = () => 0) { // ui-copy-ignore
@@ -774,9 +798,10 @@ export class SidecarPage {
       .then((response) => (response.ok ? response.json() : []))
       .catch(() => [])
     const current = await this.cdp.send('Target.getTargetInfo').then((info) => String(info?.targetInfo?.targetId ?? '')).catch(() => '')
-    return (Array.isArray(list) ? list : [])
+    const rows = (Array.isArray(list) ? list : [])
       .filter((item) => item.type === 'page' && item.webSocketDebuggerUrl !== undefined)
       .map((item) => ({ targetId: String(item.id), title: String(item.title ?? ''), url: String(item.url ?? ''), webSocketUrl: String(item.webSocketDebuggerUrl), current: String(item.id) === current }))
+    return rows
   }
 
   /**
@@ -801,18 +826,17 @@ export class SidecarPage {
        probe is only for the case where the click never made one, so it gets a
        single short look instead of the old half-second of polling. */
     if (target === null) {
-      /* Look, wait for the announcement, look again: a new tab is announced
-         before the browser lists it, so one look is not enough. */
-      const deadline = Date.now() + POPUP_GRACE_MS
-      while (target === null && Date.now() < deadline) {
-        const found = await this.findPopup(foreign)
-        if (found !== null) {
-          target = found
-          break
+      /* One look at the tab list answers the common case — a click that opened
+         nothing. When it says nothing, the announcement is the cheaper door:
+         a tab exists a moment before the browser lists it, so the wait ends on
+         the event instead of running out the window. */
+      target = await this.findPopup(foreign)
+      if (target === null) {
+        await this.waitPopup(Math.min(8, POPUP_GRACE_MS))
+        if (this.opened !== null && this.opened !== undefined && Date.now() - Number(this.opened.at ?? 0) < 2000) {
+          target = { targetId: String(this.opened.targetId), url: String(this.opened.url) }
         }
-        const left = deadline - Date.now()
-        if (left <= 0) break
-        await this.waitPopup(Math.min(8, left))
+        this.opened = null
       }
     }
     if (target === null) {
@@ -1300,7 +1324,7 @@ export class SidecarPage {
   /**
    * Whether this picture repeats the one the pane is already showing.
    * @param {string} jpeg - base64 JPEG of the new frame.
-   * @returns {boolean} true when sending it would just cost bytes.
+   * @returns {boolean} true when sending it would cost bytes.
    */
   repeats(jpeg, gap = 1000) {
     const prev = this.lastShot
@@ -1979,6 +2003,8 @@ export class Sidecar {
     /* A tab being opened for a chat: a second call for the same chat waits for
        it instead of opening a twin. */
     this.opening = new Map()
+    /* Chats whose tab was reclaimed: the column is told so it can go away. */
+    this.expired = new Map()
     /* A measurement or a test may want a profile of its own; the person's
        browser keeps the default one. */
     this.profile = String(options.profile ?? 'default')
@@ -2157,6 +2183,7 @@ export class Sidecar {
    */
   async tabFor(session, url) {
     const id = String(session ?? '')
+    this.expired?.delete(id)
     const had = this.pageFor(id)
     if (had !== null) {
       if (url !== undefined && url !== '') await had.navigate(url)
@@ -2268,23 +2295,62 @@ export class Sidecar {
       if (page === this.page) continue
       if (now - Number(page.touched ?? 0) < TAB_IDLE_MS) continue
       this.pages.delete(id)
+      /* The column is told the tab is gone, so a chat coming back to the front
+         does not re-expand a pane for a page that already went away. */
+      ;(this.expired ??= new Map()).set(String(id), Date.now())
       await page.stopCast().catch(() => {})
       await fetch(`http://127.0.0.1:${String(page.port)}/json/close/${target}`, { signal: AbortSignal.timeout(800) }).catch(() => {}) // ui-copy-ignore
       this.note(`closed an idle tab — its address is kept for the chat`)
     }
   }
 
+  /**
+   * A page already at an address, so a second open reuses it. A page another
+   * chat is driving is that chat's, and is not offered.
+   * @param {string} url - address wanted.
+   * @param {string} except - chat doing the asking.
+   * @returns {SidecarPage|null} the page, or null.
+   */
+  tabShowing(url, except) {
+    const wanted = String(url ?? '')
+    if (wanted === '' || wanted === 'about:blank') return null
+    const held = new Set()
+    for (const [who, set] of this.claims) {
+      if (String(who) === String(except)) continue
+      for (const target of set) held.add(String(target))
+    }
+    for (const page of [this.page, ...this.pages.values()]) {
+      if (page === null || page === undefined || page.cdp?.closed === true) continue
+      const target = String(page.targetId ?? '')
+      if (target === '' || held.has(target)) continue
+      if (samePlace(page.url, wanted)) return page
+    }
+    return null
+  }
+
   /**
    * @param {string} id - chat id.
    * @param {string} [url] - address to open in it.
    * @returns {Promise<SidecarPage>} a new tab for that chat.
    */
   async openTab(id, url) {
+    this.expired?.delete(String(id))
     const had = this.pageFor(id)
     if (had !== null) {
       if (url !== undefined && url !== '') await had.navigate(url)
       return had
     }
+    /* One address, one page: a browser that is already showing where this chat
+       wants to go hands that page over instead of a second copy of the same
+       address, which nobody would be able to tell apart in the tab list. */
+    const twin = this.tabShowing(url, id)
+    if (twin !== null) {
+      this.pages.set(String(id), twin)
+      this.claim(String(id), twin.targetId)
+      this.touch()
+      this.rememberTab(String(id), String(twin.url ?? url))
+      return twin
+    }
     if (this.page === null) await this.ensure()
     const port = this.page?.port ?? 0 // ui-copy-ignore
     if (port === 0) throw new Error('sidecar: no browser to open a tab in') // ui-copy-ignore
@@ -2646,7 +2712,25 @@ export class Sidecar {
    */
   async tabs(session = '') {
     const page = this.pageFor(session) ?? this.page
-    return page === null ? [] : page.tabs()
+    if (page === null) return []
+    const rows = await page.tabs()
+    /* One address is one row: the base page can be showing the very place a
+       chat's tab already shows, and two identical lines read as two pages. A
+       page a chat holds represents that address; an unheld twin is left out,
+       and the rows that stay keep the browser's order, which is the index
+       space the tab tools address their rows by. */
+    const held = new Set()
+    for (const set of this.claims.values()) for (const target of set) held.add(String(target))
+    const seen = new Set()
+    const kept = []
+    for (const row of [...rows].filter((item) => held.has(item.targetId)).concat(rows.filter((item) => !held.has(item.targetId)))) {
+      const key = placeKey(row.url)
+      if (key !== '' && seen.has(key)) continue
+      if (key !== '') seen.add(key)
+      kept.push(row)
+    }
+    kept.sort((a, b) => rows.indexOf(a) - rows.indexOf(b))
+    return kept
   }
 
   /**
@@ -3074,8 +3158,9 @@ export class Sidecar {
        question about which site it used to be. */
     const remembered = this.rememberedTab(id)
     const page = id === '' ? null : this.pageFor(id)
-    if (page === null || page === undefined) return { url: '', title: '', viewers: 0, alive: false, remembered } // ui-copy-ignore
-    return { url: String(page.url ?? ''), title: String(page.title ?? ''), viewers: page.frames?.size ?? 0, alive: true, remembered } // ui-copy-ignore
+    const expired = this.expired?.has(id) === true
+    if (page === null || page === undefined) return { url: '', title: '', viewers: 0, alive: false, expired, remembered } // ui-copy-ignore
+    return { url: String(page.url ?? ''), title: String(page.title ?? ''), viewers: page.frames?.size ?? 0, alive: true, expired, remembered } // ui-copy-ignore
   }
 
   async state() {

package/tools.js

@@ -310,7 +310,17 @@ export async function outcome(page, before) {
   const [wasTitle, wasUrl, wasText, wasNodes] = before.split('|')
   const [nowTitle, nowUrl, nowText, nowNodes] = after.split('|')
   if (after === before) return ' · no visible change'
-  if (nowUrl !== wasUrl) return ` · navigated to ${String(nowUrl).slice(0, 300)}`
+  if (nowUrl !== wasUrl) {
+    /* The brief on the same line already names the address this step went to.
+       What it cannot say is whether the page moved within itself, so a jump to
+       another spot on the same address is said as the spot alone. */
+    const was = String(wasUrl ?? '')
+    const now = String(nowUrl ?? '')
+    const base = (value) => (value.includes('#') ? value.slice(0, value.indexOf('#')) : value)
+    const spot = now.includes('#') ? now.slice(now.indexOf('#')) : ''
+    if (spot !== '' && base(was) === base(now)) return ` · ${spot.slice(0, 120)}`
+    return ' · new page'
+  }
   const words = Math.abs(Number(nowText ?? 0) - Number(wasText ?? 0))
   const nodes = Math.abs(Number(nowNodes ?? 0) - Number(wasNodes ?? 0))
   if (nowTitle !== wasTitle) return ' · page moved on'
@@ -352,9 +362,27 @@ export function withoutSeenAddress(page, url, text) {
   return body.slice(first.length + 1)
 }
 
+/** The focus line repeats the control the call named: say the name once. */
+export function dropSameFocus(line, args) {
+  const squeezed = (value) => String(value ?? '').toLowerCase().replace(/\s+/g, '')
+  const named = squeezed(args?.text ?? args?.name ?? args?.ref ?? '')
+  if (named === '') return line
+  const at = line.indexOf(' · focus ')
+  if (at < 0) return line
+  const head = line.slice(0, at)
+  const parts = line.slice(at + ' · focus '.length).split(' · ')
+  const said = String(parts[0] ?? '')
+  /* A field carries a value the words do not: that part is news, so it stays. */
+  if (said.includes(' = ')) return line
+  const label = squeezed(said)
+  if (label !== named && !label.includes(named) && !named.includes(label)) return line
+  const rest = parts.slice(1)
+  return rest.length === 0 ? head : `${head} · ${rest.join(' · ')}`
+}
+
 async function acted(page, args, look, label) {
   if (args?.read === true) return await look()
-  return `ok ${label} · ${oncePerPage(page, await brief(page))}`
+  return `ok ${label} · ${dropSameFocus(oncePerPage(page, await brief(page)), args)}`
 }
 
 /**