dsh-inner-browser-use 0.34.97 → 0.34.99

package/client.js

@@ -73,7 +73,7 @@ window.__ModuleLoader__.load({
       '.dshib-side-win[data-on="1"]{background:var(--dsw-alias-bg-subtle);color:var(--dsw-alias-label-primary)}',
       '.dshib-side-win > span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
       '.dshib-side-stage{flex:1 1 auto;position:relative;min-width:0;min-height:0;display:flex;align-items:center;justify-content:center;overflow:hidden;background:var(--dsw-alias-bg-base);outline:none;cursor:default}',
-      '.dshib-side-frame{display:block;user-select:none;-webkit-user-drag:none;cursor:default}',
+      '.dshib-side-frame{position:absolute;inset:0;display:block;width:100%;height:100%;object-fit:contain;user-select:none;-webkit-user-drag:none;cursor:default}',
       '.dshib-side-ime{position:absolute;width:1px;height:1px;padding:0;margin:0;border:0;resize:none;overflow:hidden;opacity:0;pointer-events:none}',
       /* The black arrow is the agent's pointer, not the person's cursor: both are
          on screen at once, and moving the mouse never takes the arrow over. */
@@ -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)
@@ -571,9 +645,27 @@ window.__ModuleLoader__.load({
           .catch(() => {})
       }
 
-      const scale = size.w > 0 && size.h > 0 ? Math.min(size.w / view.w, size.h / view.h) : 0
-      const padX = (size.w - view.w * scale) / 2
-      const padY = (size.h - view.h * scale) / 2
+      /* Where the page actually got drawn inside the column: the frame fills
+         the stage and the picture sits inside it, so the answer comes from the
+         element that is on screen rather than from the last size remembered.
+         A stale measure can then never shrink the picture to a thumbnail. */
+      const frameEl = React.useRef(null)
+      const picture = () => {
+        const at = frameEl.current
+        const areaEl = stage.current
+        if (at === null || at === undefined || areaEl === null || areaEl === undefined) return null
+        if (!(view.w > 0) || !(view.h > 0)) return null
+        const a = at.getBoundingClientRect()
+        const b = areaEl.getBoundingClientRect()
+        if (!(a.width > 1) || !(a.height > 1)) return null
+        const scale = Math.min(a.width / view.w, a.height / view.h)
+        if (!(scale > 0)) return null
+        return {
+          scale,
+          x: a.left - b.left + (a.width - view.w * scale) / 2,
+          y: a.top - b.top + (a.height - view.h * scale) / 2,
+        }
+      }
 
       /* The column tells the page how big it is, a beat after the resize stops:
          a page that relayouts on every pointer step would never settle. */
@@ -655,10 +747,12 @@ window.__ModuleLoader__.load({
       }
       const toView = (event) => {
         const el = stage.current
-        if (el === null || scale <= 0) return null
+        if (el === null) return null
+        const spot = picture()
+        if (spot === null) return null
         const box = el.getBoundingClientRect()
-        const x = (event.clientX - box.left - padX) / scale
-        const y = (event.clientY - box.top - padY) / scale
+        const x = (event.clientX - box.left - spot.x) / spot.scale
+        const y = (event.clientY - box.top - spot.y) / spot.scale
         if (x < 0 || y < 0 || x > view.w || y > view.h) return null
         return { x: Math.round(x), y: Math.round(y) }
       }
@@ -754,6 +848,7 @@ window.__ModuleLoader__.load({
           h('div', { className: 'dshib-side-note' }, L('side.foreign')))
       }
       const pointer = person === true || hand === true ? null : ptr
+      const spot = pointer === null ? null : (picture() ?? { scale: 1, x: 0, y: 0 })
       const noteText = phase === 'failed' ? note || L('side.failed') : phase === 'live' ? L('side.empty') : L('side.connecting')
       return h('div', { className: 'dshib-side' },
         h('div', { className: 'dshib-side-bar' },
@@ -820,7 +915,7 @@ window.__ModuleLoader__.load({
             tabIndex: 0,
             spellCheck: false,
             'aria-label': L('side.type'),
-            style: pointer === null ? undefined : { left: `${padX + pointer.x * scale}px`, top: `${padY + pointer.y * scale}px` },
+            style: pointer === null || spot === null ? undefined : { left: `${spot.x + pointer.x * spot.scale}px`, top: `${spot.y + pointer.y * spot.scale}px` },
             onCompositionStart: () => {
               composing.current = true
             },
@@ -839,9 +934,10 @@ window.__ModuleLoader__.load({
           }),
           frame === null ? null : h('img', {
             className: 'dshib-side-frame',
+            ref: frameEl,
             src: `data:image/jpeg;base64,${frame.jpeg}`,
-            width: Math.max(1, Math.round(view.w * scale)),
-            height: Math.max(1, Math.round(view.h * scale)),
+            width: Math.max(1, Math.round(view.w)),
+            height: Math.max(1, Math.round(view.h)),
             alt: '', // ui-copy-ignore
             draggable: false,
           }),
@@ -849,7 +945,7 @@ window.__ModuleLoader__.load({
             className: 'dshib-side-ptr',
             src: SIDE_POINTER, // ui-copy-ignore
             alt: '', // ui-copy-ignore
-            style: { left: `${padX + pointer.x * scale}px`, top: `${padY + pointer.y * scale}px` },
+            style: spot === null ? undefined : { left: `${spot.x + pointer.x * spot.scale}px`, top: `${spot.y + pointer.y * spot.scale}px` },
           })))
     }
   },

package/index.js

@@ -20,7 +20,7 @@
  * learns no port and no secret. // ui-copy-ignore
  */
 
-import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { appendFileSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { Sidecar } from './sidecar.js?v=1'
@@ -50,6 +50,27 @@ function writeMirror(value) {
   }
 }
 
+/** The note stops growing: past this size the oldest half goes, so a long-lived run never fills the disk. */
+const NOTES_MAX = 256 * 1024
+const NOTES_KEEP = 128 * 1024
+
+/**
+ * Add one line to the mirror's own note, keeping the file bounded.
+ * @param {string} line - what happened, one line.
+ */
+export function note(line) {
+  const file = join(STATE_DIR, 'asks.log')
+  try {
+    mkdirSync(STATE_DIR, { recursive: true })
+    appendFileSync(file, `${new Date().toISOString()} ${line}\n`)
+    if (statSync(file).size <= NOTES_MAX) return
+    const whole = readFileSync(file, 'utf8')
+    writeFileSync(file, whole.slice(whole.length - NOTES_KEEP).replace(/^[^\n]*\n/, ''))
+  } catch {
+    /* a note that cannot be written must not take the mirror down */
+  }
+}
+
 /** Route prefix owned by this plugin. Never under `/api`, which is the Host's own channel. */ // ui-copy-ignore
 export const ROUTE = '/dsh-inner-browser-use'
 
@@ -131,15 +152,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 +177,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 +209,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,8 +356,8 @@ 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)
-        appendFileSync(join(STATE_DIR, 'asks.log'), `${new Date().toISOString()} asked ${owner.slice(-8)} to draw the mirror again\n`)
+        bridge.want(owner, Date.now(), 'keepalive')
+        note(`asked ${owner.slice(-8)} to draw the mirror again`)
       } catch {}
     }, 4000)
     timer.unref?.()
@@ -504,7 +532,7 @@ export function apply(ctx) {
         if (Date.now() - before > 2000) {
           lastAsk.set(chat, Date.now())
           try {
-            appendFileSync(join(STATE_DIR, 'asks.log'), `${new Date().toISOString()} ${chat.slice(-8)} alive=${String(said?.alive === true)} viewers=${String(said?.viewers ?? 0)}\n`)
+            note(`${chat.slice(-8)} alive=${String(said?.alive === true)} viewers=${String(said?.viewers ?? 0)}`)
           } catch {}
         }
       }
@@ -708,7 +736,17 @@ export function apply(ctx) {
       const body = await readBody(req).then((raw) => JSON.parse(raw || '{}')).catch(() => ({}))
       const who = acting(body)
       if (who === '') return
-      json(200, { ok: true, forgot: bridge.forget(who) })
+      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
+         agent asks for it again in the meantime. */
+      try {
+        if (sidecar.watched() === 0) {
+          sidecar.touch(REST_MS)
+          note('said ' + who.slice(-8) + ' closed the mirror - browser rests in a minute')
+        }
+      } catch { /* a browser that never started needs no rest timer */ }
+      json(200, { ok: true, forgot })
       return
     }
 

package/package.json

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

@@ -95,6 +95,12 @@ export function nextQuality(current, base64) {
 
 /** Idle lifetime, so a forgotten sidecar does not sit on a login forever. */
 const IDLE_MS = 15 * 60_000
+/* A pane the person closed is a stronger signal than a pane nobody touched: the
+   browser is put away a minute later unless someone asks for it again. A whole
+   Chrome with its renderers is a few hundred megabytes, and leaving it up for a
+   quarter of an hour after a deliberate close is exactly the cost they did not
+   want. */
+const REST_MS = 60_000
 /* One browser serves every chat, but a chat that is not on screen need not keep
    a full renderer alive for ever: past this many chats the oldest unwatched tab
    is closed, and its address brings it back on the next visit. */
@@ -2836,7 +2842,18 @@ export class Sidecar {
     }
   }
 
-  touch() {
+  /** @returns {number} how many panes are watching a picture right now. */
+  watched() {
+    let n = this.page?.frames?.size ?? 0
+    for (const page of this.pages?.values() ?? []) n += page.frames?.size ?? 0
+    return n
+  }
+
+  /**
+   * Starts the idle clock again.
+   * @param {number} [ms] - how long a browser nobody watches may stay up.
+   */
+  touch(ms = IDLE_MS) {
     if (this.idle !== null) clearTimeout(this.idle)
     this.idle = setTimeout(() => {
       this.idle = null
@@ -2849,7 +2866,7 @@ export class Sidecar {
         return
       }
       void this.shutdown()
-    }, IDLE_MS)
+    }, ms)
     this.idle.unref?.()
   }