dsh-inner-browser-use 0.34.96 → 0.34.98

package/client.js

@@ -119,12 +119,51 @@ window.__ModuleLoader__.load({
               return ''
             }
           }
-          const closeHere = (sessionId, byPerson = false) => {
-            /* A tab the person closed is not a tab they want back on return. */
+          /* The chat that asked for the pane, and the chats whose pane the
+             person closed. A strip close and a layout restore do not both
+             report themselves here, so the mark is kept on this side too: no
+             automatic ask may redraw a column the person shut. */
+          let openWho = ''
+          let openAt = 0
+          let paneSeen = false
+          let missing = 0
+          const closedAt = new Map()
+          const hasPane = (sessionId) => {
             try {
-              void fetch(`${ROUTE}/sidecar/forget?session=${encodeURIComponent(sessionId)}`, { method: 'POST' }) // ui-copy-ignore
+              const rows = surface?.tabsIn?.(sessionId) ?? []
+              return rows.some((row) => {
+                const kind = String(row?.kind ?? row?.record?.kind ?? '')
+                const id = String(row?.id ?? row?.record?.id ?? '')
+                return kind === SIDE_KIND || id === SIDE_ID
+              })
             } catch {
-              /* a page that cannot hear it keeps its note */
+              return false
+            }
+          }
+          const closeHere = (sessionId, byPerson = false) => {
+            if (sessionId === '') return
+            closedAt.set(sessionId, Date.now())
+            if (openWho === sessionId) {
+              openWho = ''
+              openAt = 0
+              paneSeen = false
+              missing = 0
+            }
+            /* A note is sent only when the person is quitting the mirror, not when a
+               chat switch closes this column: the switch's own ask claims the
+               mirror a moment later, and a late note would take it away from the
+               chat that just asked. */
+            if (byPerson === true) {
+              /* A close usually unmounts the pane in the same tick, which cancels
+                 an ordinary request; a beacon is delivered after the page is gone,
+                 so the note always arrives. */
+              const url = `${ROUTE}/sidecar/forget?session=${encodeURIComponent(sessionId)}` // ui-copy-ignore
+              try {
+                const sent = typeof navigator?.sendBeacon === 'function' && navigator.sendBeacon(url) === true
+                if (sent !== true) void fetch(url, { method: 'POST' })
+              } catch {
+                /* a page that cannot hear it keeps its note */
+              }
             }
             let records = []
             try {
@@ -149,10 +188,23 @@ window.__ModuleLoader__.load({
               }
             }
           }
-          const ask = (sessionId) => {
+          const ask = (sessionId, reason = 'ask', at = 0) => {
             if (sessionId === '' || mountedOf() !== sessionId) return
+            const shut = closedAt.get(sessionId)
+            /* A slow beat that only wants the frames back must not put a closed
+               column on screen again: it may refresh a pane that is drawn and
+               nothing else. */
+            if (reason === 'keepalive' && (shut !== undefined || !hasPane(sessionId))) return
+            /* A real ask is only newer than the close that preceded it: a
+               replayed one from before the person shut the pane stays spent. */
+            if (shut !== undefined && (reason !== 'ask' || (at !== 0 && at <= shut))) return
+            if (shut !== undefined) closedAt.delete(sessionId)
             if (ownerSession !== '' && ownerSession !== sessionId) closeHere(ownerSession)
             ownerSession = sessionId
+            openWho = sessionId
+            missing = 0
+            paneSeen = hasPane(sessionId)
+            if (paneSeen !== true) openAt = Date.now()
             try {
               if (typeof surface?.openTabIn === 'function') surface.openTabIn(sessionId, SIDE_KIND, {})
               else if (typeof surface?.openTab === 'function') surface.openTab(SIDE_KIND)
@@ -160,6 +212,25 @@ window.__ModuleLoader__.load({
               /* a column that refuses keeps its own tabs */
             }
           }
+          /* The pane this chat asked for can be taken down by paths that never
+             call onClose. One that was drawn and is gone was closed by the
+             person, and that is the answer this watcher waits for. */
+          const watchPane = () => {
+            if (openWho === '') return
+            if (mountedOf() !== openWho) return
+            if (hasPane(openWho)) {
+              paneSeen = true
+              missing = 0
+              return
+            }
+            /* A pane the person never saw draw is still being built; only one
+               that was on screen and then vanished is a close. */
+            if (paneSeen !== true) return
+            if (Date.now() - openAt < 2500) return
+            missing += 1
+            if (missing < 2) return
+            closeHere(openWho, true)
+          }
           /* The same rule on this side: a second mount of the same tab is a
              no-op, not a thrown error that takes the pane down. */
           const safely = (register) => {
@@ -177,7 +248,7 @@ window.__ModuleLoader__.load({
             priority: 'extension',
             title: () => L('side.label'),
             /* The tab strip's close control is not the pane's own button: a
-               tab closed there never told the host, the ask stayed alive, and
+               tab closed there never sent the note, the ask stayed alive, and
                the keepalive put the mirror back a few seconds later — a tab
                the person closed that would not stay closed. Every close path
                ends here. */
@@ -186,7 +257,7 @@ window.__ModuleLoader__.load({
           disposers.push(scope.slots.inject(SLOT, () => scope.slots.register({
             name: SLOT, // ui-copy-ignore
             key: SIDE_ID, // ui-copy-ignore
-            inject: (sessionId) => ({ sessionId, dropMirror: () => closeHere(sessionId) }),
+            inject: (sessionId) => ({ sessionId, dropMirror: () => closeHere(sessionId, true) }),
           }, SidecarBody)))
           disposers.push(scope.slots.inject(TITLE_SLOT, () => scope.slots.register({
             name: TITLE_SLOT, // ui-copy-ignore
@@ -195,7 +266,7 @@ window.__ModuleLoader__.load({
           }, () => h('span', { className: 'dshib-title' }, L('side.label')))))
           /* The mirror comes only when this chat asked for it: the ask is pushed
              to this chat's page, and nothing opens by itself. // ui-copy-ignore */
-          sidecarOpener = (sessionId) => ask(sessionId)
+          sidecarOpener = (sessionId, reason = 'ask', at = 0) => ask(sessionId, reason, at)
           /* The ask arrives on this chat's own downlink, so a frame for another
              chat never reaches this column. The stream follows the chat on
              screen: a switch closes the old one and opens the new one. */
@@ -231,7 +302,7 @@ window.__ModuleLoader__.load({
                 }
                 if (frame?.type !== 'sidecar-wanted') return
                 const asked = String(frame.session ?? '')
-                if (asked !== '') sidecarOpener?.(asked)
+                if (asked !== '') sidecarOpener?.(asked, String(frame.reason ?? 'ask'), Number(frame.at ?? 0))
               })
               askSource = source
               askWho = who
@@ -276,7 +347,7 @@ window.__ModuleLoader__.load({
                     again()
                     return
                   }
-                  ask(who)
+                  ask(who, 'restore')
                 })
                 .catch(again)
             } catch {
@@ -285,7 +356,10 @@ window.__ModuleLoader__.load({
           }
           restore()
           const offAsk = watchAsk()
-          const pollAsk = setInterval(syncAsk, 1000)
+          const pollAsk = setInterval(() => {
+            syncAsk()
+            watchPane()
+          }, 1000)
           const stopAsk = () => {
             clearInterval(pollAsk)
             for (const timer of restoreTimers) clearTimeout(timer)
@@ -598,7 +672,16 @@ window.__ModuleLoader__.load({
           })
             .then((answer) => (answer.ok === true ? answer.json() : { ok: false }))
             .then((said) => {
-              if (!live || said?.ok === true || tries >= 5) return
+              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)
             })

package/index.js

@@ -131,15 +131,16 @@ export class Bridge {
    * Remember that a chat wants the mirror, and tell it now if it is listening.
    * @param {string} sessionId - chat that asked.
    * @param {number} [at] - when it asked; older asks are not replayed.
+   * @param {string} [reason] - 'ask' for a real request, 'keepalive' for a nudge.
    * @returns {boolean} whether a live tab took the frame.
    */
-  want(sessionId, at = Date.now()) {
+  want(sessionId, at = Date.now(), reason = 'ask') {
     const id = this.canon(sessionId)
     if (id === '') return false
     this.claim(id)
     this.wanted = { session: id, at }
     if (this.persist === true) writeMirror({ owner: this.owner, session: id, at })
-    return this.push(id, { type: 'sidecar-wanted', session: id, at })
+    return this.push(id, { type: 'sidecar-wanted', session: id, at, reason })
   }
 
   /**
@@ -155,7 +156,7 @@ export class Bridge {
        ask older than two minutes is spent and is not replayed. */
     const ask = this.wanted
     if (ask.session === sessionId && Date.now() - ask.at <= 120_000) {
-      this.push(sessionId, { type: 'sidecar-wanted', session: sessionId, at: ask.at })
+      this.push(sessionId, { type: 'sidecar-wanted', session: sessionId, at: ask.at, reason: 'ask' })
     }
   }
 
@@ -187,14 +188,20 @@ export class Bridge {
   }
 
   /**
-   * Forget a mirror nobody is waiting for any more.
+   * Give the mirror up: the person closed the column, so the chat stops owning
+   * it and no keepalive may ask for it again. Ownership is what the column
+   * reads on reload, so it has to be dropped on disk as well as in memory.
    * @param {string} sessionId - chat that closed its tab.
-   * @returns {boolean} whether the ask was the remembered one.
+   * @returns {boolean} whether this chat held the mirror or the ask.
    */
   forget(sessionId) {
-    if (sessionId === '' || this.wanted.session !== sessionId) return false
+    const id = this.canon(sessionId)
+    if (id === '') return false
+    const held = this.owner === id || this.wanted.session === id
     this.wanted = { session: '', at: 0 }
-    return true
+    if (this.owner === id) this.owner = ''
+    if (this.persist === true) writeMirror({ owner: this.owner, session: '', at: 0 })
+    return held
   }
 
   /** Close every stream. */
@@ -328,7 +335,7 @@ export function apply(ctx) {
         const due = nudgeDue({ askedAgo: Date.now() - (lastAsk.get(owner) ?? 0), sinceLast: Date.now() - last }) // ui-copy-ignore
         if (due !== true) return
         last = Date.now()
-        bridge.want(owner)
+        bridge.want(owner, Date.now(), 'keepalive')
         appendFileSync(join(STATE_DIR, 'asks.log'), `${new Date().toISOString()} asked ${owner.slice(-8)} to draw the mirror again\n`)
       } catch {}
     }, 4000)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-inner-browser-use",
-  "version": "0.34.96",
+  "version": "0.34.98",
   "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

@@ -1962,6 +1962,10 @@ export class Sidecar {
     /* One tab per chat: a second chat opening an address gets a tab of its
        own, so neither can navigate the other's page away. */
     this.pages = new Map()
+    /* Every tab a chat has driven, so its column can offer its own windows
+       back after it switches away: a tab the chat left is still its own, and a
+       tab nobody claimed belongs to no column at all. */
+    this.claims = new Map()
     /* Tabs left behind by an earlier plugin load are closed once, on the first
        call that finds this browser: a profile used for weeks otherwise keeps a
        renderer per chat that ever opened it. */
@@ -2048,6 +2052,41 @@ export class Sidecar {
    * @param {string} session - chat id, empty for the default tab.
    * @returns {SidecarPage | null} the tab, if the browser is up.
    */
+  /**
+   * Remember that a tab belongs to a chat: switching away from it keeps it in
+   * that chat's window list, and no other chat can see it.
+   * @param {string} session - chat that drove the tab. // ui-copy-ignore
+   * @param {string} targetId - the browser target.
+   */
+  claim(session, targetId) {
+    const who = String(session ?? '')
+    const target = String(targetId ?? '')
+    if (who === '' || target === '') return
+    let set = this.claims.get(who)
+    if (set === undefined) {
+      set = new Set()
+      this.claims.set(who, set)
+    }
+    /* A chat cannot hold an unbounded list: the oldest tab it left falls off. */
+    if (set.size >= 12 && set.has(target) !== true) {
+      const first = set.values().next()
+      if (first.done !== true) set.delete(first.value)
+    }
+    set.add(target)
+  }
+
+  /**
+   * Forget a tab a chat no longer has.
+   * @param {string} session - chat that owned it. // ui-copy-ignore
+   * @param {string} targetId - the browser target.
+   */
+  unclaim(session, targetId) {
+    const set = this.claims.get(String(session ?? ''))
+    if (set === undefined) return
+    set.delete(String(targetId ?? ''))
+    if (set.size === 0) this.claims.delete(String(session ?? ''))
+  }
+
   pageFor(session) {
     const id = String(session ?? '')
     if (id === '') return this.page
@@ -2265,6 +2304,7 @@ export class Sidecar {
     await cdp.ready
     const page = await this.bind(await new SidecarPage(cdp, this.profile, port, () => this.holding()).start()) // ui-copy-ignore
     this.pages.set(id, page)
+    this.claim(id, page.targetId)
     this.touch()
     this.rememberTab(id, address)
     return page
@@ -2614,10 +2654,21 @@ export class Sidecar {
     const list = await this.tabs(session)
     const page = this.pageFor(session) ?? this.page
     const foreign = new Set(typeof page?.siblings === 'function' ? page.siblings().map(String) : [])
+    const who = String(session ?? '')
+    const claimed = this.claims.get(who) ?? new Set()
+    /* Tabs the browser no longer has must not linger in a chat's list. */
+    if (claimed.size > 0) {
+      const live = new Set(list.map((row) => String(row.targetId)))
+      for (const id of [...claimed]) if (live.has(id) !== true) claimed.delete(id)
+      if (claimed.size === 0) this.claims.delete(who)
+    }
     const shown = []
     for (let at = 0; at < list.length; at += 1) {
       const row = list[at]
       if (foreign.has(String(row.targetId))) continue
+      /* A tab nobody in this chat drove is not this chat's window: a page
+         opened behind the browser's back belongs to no column. */
+      if (row.current !== true && claimed.has(String(row.targetId)) !== true) continue
       /* The index is the browser's own row, not this shorter list's: switching
          goes back through `tabs()` unfiltered. */
       shown.push({ title: String(row.title ?? ''), url: String(row.url ?? ''), current: row.current === true, index: at })
@@ -2666,6 +2717,7 @@ export class Sidecar {
       await cdp.ready
       const page = await this.bind(await new SidecarPage(cdp, this.profile, mine.port, () => this.holding()).start()) // ui-copy-ignore
       this.pages.set(String(session), page)
+      this.claim(session, tab.targetId)
       mine.cdp.send('Page.stopScreencast').catch(() => {})
       mine.cdp.close()
       await page.cast()
@@ -2701,6 +2753,7 @@ export class Sidecar {
       alone = other < 0
       if (!alone) await this.useTab(other, session)
     }
+    this.unclaim(session, tab.targetId)
     if (port > 0) await fetch(`http://127.0.0.1:${port}/json/close/${tab.targetId}`, { signal: AbortSignal.timeout(1000) }).catch(() => {}) // ui-copy-ignore
     if (alone && mine !== null) {
       /* The chat still needs somewhere to go: a fresh tab in the same browser. */