@poncho-ai/browser 0.6.24 → 0.6.26

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/browser@0.6.24 build /home/runner/work/poncho-ai/poncho-ai/packages/browser
+> @poncho-ai/browser@0.6.26 build /home/runner/work/poncho-ai/poncho-ai/packages/browser
 > tsup src/index.ts --format esm --dts
 
 CLI Building entry: src/index.ts
@@ -7,8 +7,8 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 47.13 KB
-ESM ⚡️ Build success in 67ms
+ESM dist/index.js 47.98 KB
+ESM ⚡️ Build success in 60ms
 DTS Build start
-DTS ⚡️ Build success in 5077ms
-DTS dist/index.d.ts 13.69 KB
+DTS ⚡️ Build success in 4894ms
+DTS dist/index.d.ts 13.77 KB

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @poncho-ai/browser
 
+## 0.6.26
+
+### Patch Changes
+
+- [#182](https://github.com/cesr/poncho-ai/pull/182) [`5ca3615`](https://github.com/cesr/poncho-ai/commit/5ca361576cbe1a97e6315f550a58a302b4e70aca) Thanks [@cesr](https://github.com/cesr)! - Keep host viewport listeners alive across browser sessions. `onFrame` /
+  `onStatus` listeners were stored inside the per-conversation `ConversationTab`
+  object, so `closeTab` (and LRU eviction) deleted them along with the tab. When
+  an agent closed one browser and opened another in the same conversation, the
+  new tab had empty listener sets — the host's live-viewport subscription was
+  silently orphaned, so the second session's `browser:status` / frames never
+  reached the client until it reconnected (the "pill/sheet doesn't appear, or is
+  left over after close, until I navigate away and back" bug). Listeners now live
+  in session-level maps keyed by conversationId, independent of any tab's
+  lifetime; they persist until the host unsubscribes, and `emitStatus` delivers
+  the final `active:false` on close before the tab is removed.
+
+## 0.6.25
+
+### Patch Changes
+
+- [#180](https://github.com/cesr/poncho-ai/pull/180) [`4e27887`](https://github.com/cesr/poncho-ai/commit/4e27887655eda1d420b8f69097cfc79e42f9596c) Thanks [@cesr](https://github.com/cesr)! - Fix a deadlock that wedged the browser session after the first lock-acquire
+  timeout. `lock()` pushed a wrapper closure onto `_lockQueue` but, on the 30s
+  timeout, tried to remove the entry with `indexOf(resolve)` — searching for a
+  different function — so the timed-out waiter was never spliced out. When the
+  current owner later called `unlock()`, it `shift()`ed that zombie waiter and
+  invoked it; `resolve()` on the already-rejected promise was a no-op, so the
+  unlock was consumed by a dead waiter, `_locked` stayed `true`, and no live
+  operation could ever acquire the lock again. Every subsequent browser call
+  then returned "Browser operation timed out waiting for lock (30s)" until the
+  session was torn down. Waiters are now tracked as objects with a `settled`
+  flag: a timed-out waiter removes itself from the queue, and `unlock()` skips
+  any already-settled waiters when handing off ownership.
+
 ## 0.6.24
 
 ### Patch Changes

package/dist/index.d.ts

@@ -80,6 +80,8 @@ declare class BrowserSession {
     private readonly sessionId;
     private manager;
     private readonly tabs;
+    private readonly frameListeners;
+    private readonly statusListeners;
     private _contextStealthInstalled;
     private readonly _uaOverrideApplied;
     private _lockQueue;

package/dist/index.js

@@ -250,6 +250,15 @@ var BrowserSession = class {
   manager;
   // Tab management: conversationId → tab state
   tabs = /* @__PURE__ */ new Map();
+  // Viewport listeners, keyed by conversationId and kept SEPARATE from the
+  // tab. A host (e.g. a live iOS viewport) subscribes once; its listeners must
+  // outlive any individual tab so that closing one browser and opening another
+  // in the same conversation — or an LRU tab eviction — doesn't silently
+  // orphan the subscription (the symptom: the second session's status/frames
+  // never reach the client until it reconnects). Tabs come and go; listeners
+  // persist until the host unsubscribes.
+  frameListeners = /* @__PURE__ */ new Map();
+  statusListeners = /* @__PURE__ */ new Map();
   // Whether context-level stealth init script has been installed
   _contextStealthInstalled = false;
   // Track which tabs have had per-page CDP UA override applied
@@ -275,21 +284,33 @@ var BrowserSession = class {
       return;
     }
     return new Promise((resolve2, reject) => {
+      const waiter = { settled: false, grant: () => {
+      } };
       const timer = setTimeout(() => {
-        const idx = this._lockQueue.indexOf(resolve2);
+        if (waiter.settled) return;
+        waiter.settled = true;
+        const idx = this._lockQueue.indexOf(waiter);
         if (idx !== -1) this._lockQueue.splice(idx, 1);
         reject(new Error("Browser operation timed out waiting for lock (30s)"));
       }, 3e4);
-      this._lockQueue.push(() => {
+      waiter.grant = () => {
+        if (waiter.settled) return;
+        waiter.settled = true;
         clearTimeout(timer);
         resolve2();
-      });
+      };
+      this._lockQueue.push(waiter);
     });
   }
   unlock() {
-    const next = this._lockQueue.shift();
-    if (next) next();
-    else this._locked = false;
+    while (this._lockQueue.length > 0) {
+      const next = this._lockQueue.shift();
+      if (!next.settled) {
+        next.grant();
+        return;
+      }
+    }
+    this._locked = false;
   }
   // -----------------------------------------------------------------------
   // Core browser + tab management
@@ -537,13 +558,10 @@ var BrowserSession = class {
       if (realTabs > 0) {
         await mgr.newTab();
       }
-      const existing = tab;
       tab = {
         tabIndex: mgr.getActiveIndex(),
         active: true,
-        lastUsed: Date.now(),
-        frameListeners: existing?.frameListeners ?? /* @__PURE__ */ new Set(),
-        statusListeners: existing?.statusListeners ?? /* @__PURE__ */ new Set()
+        lastUsed: Date.now()
       };
       this.tabs.set(conversationId, tab);
     } else {
@@ -817,15 +835,15 @@ var BrowserSession = class {
         (frame) => {
           const cid = this._screencastConversation;
           if (!cid) return;
-          const t = this.tabs.get(cid);
-          if (!t) return;
+          const listeners = this.frameListeners.get(cid);
+          if (!listeners || listeners.size === 0) return;
           const browserFrame = {
             data: frame.data,
             width: frame.metadata.deviceWidth,
             height: frame.metadata.deviceHeight,
             timestamp: Date.now()
           };
-          for (const listener of t.frameListeners) {
+          for (const listener of listeners) {
             try {
               listener(browserFrame);
             } catch {
@@ -853,29 +871,37 @@ var BrowserSession = class {
   // Per-conversation event listeners
   // -----------------------------------------------------------------------
   onFrame(conversationId, listener) {
-    let tab = this.tabs.get(conversationId);
-    if (!tab) {
-      tab = { tabIndex: -1, active: false, lastUsed: Date.now(), frameListeners: /* @__PURE__ */ new Set(), statusListeners: /* @__PURE__ */ new Set() };
-      this.tabs.set(conversationId, tab);
+    let set = this.frameListeners.get(conversationId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.frameListeners.set(conversationId, set);
     }
-    tab.frameListeners.add(listener);
+    set.add(listener);
     return () => {
-      tab.frameListeners.delete(listener);
-      if (tab.frameListeners.size === 0 && this._screencastConversation === conversationId) {
-        this.stopScreencast().catch(() => {
-        });
+      const s = this.frameListeners.get(conversationId);
+      if (!s) return;
+      s.delete(listener);
+      if (s.size === 0) {
+        this.frameListeners.delete(conversationId);
+        if (this._screencastConversation === conversationId) {
+          this.stopScreencast().catch(() => {
+          });
+        }
       }
     };
   }
   onStatus(conversationId, listener) {
-    let tab = this.tabs.get(conversationId);
-    if (!tab) {
-      tab = { tabIndex: -1, active: false, lastUsed: Date.now(), frameListeners: /* @__PURE__ */ new Set(), statusListeners: /* @__PURE__ */ new Set() };
-      this.tabs.set(conversationId, tab);
+    let set = this.statusListeners.get(conversationId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.statusListeners.set(conversationId, set);
     }
-    tab.statusListeners.add(listener);
+    set.add(listener);
     return () => {
-      tab.statusListeners.delete(listener);
+      const s = this.statusListeners.get(conversationId);
+      if (!s) return;
+      s.delete(listener);
+      if (s.size === 0) this.statusListeners.delete(conversationId);
     };
   }
   // -----------------------------------------------------------------------
@@ -1075,8 +1101,9 @@ var BrowserSession = class {
       url: tab?.url,
       interactionAllowed: tab?.active ?? false
     };
-    if (tab) {
-      for (const listener of tab.statusListeners) {
+    const listeners = this.statusListeners.get(conversationId);
+    if (listeners) {
+      for (const listener of listeners) {
         try {
           listener(status);
         } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/browser",
-  "version": "0.6.24",
+  "version": "0.6.26",
   "description": "Browser automation for Poncho agents, powered by agent-browser",
   "repository": {
     "type": "git",

package/src/session.ts

@@ -144,8 +144,6 @@ interface ConversationTab {
   url?: string;
   active: boolean;
   lastUsed: number;
-  frameListeners: Set<FrameListener>;
-  statusListeners: Set<StatusListener>;
 }
 
 export class BrowserSession {
@@ -156,6 +154,16 @@ export class BrowserSession {
   // Tab management: conversationId → tab state
   private readonly tabs = new Map<string, ConversationTab>();
 
+  // Viewport listeners, keyed by conversationId and kept SEPARATE from the
+  // tab. A host (e.g. a live iOS viewport) subscribes once; its listeners must
+  // outlive any individual tab so that closing one browser and opening another
+  // in the same conversation — or an LRU tab eviction — doesn't silently
+  // orphan the subscription (the symptom: the second session's status/frames
+  // never reach the client until it reconnects). Tabs come and go; listeners
+  // persist until the host unsubscribes.
+  private readonly frameListeners = new Map<string, Set<FrameListener>>();
+  private readonly statusListeners = new Map<string, Set<StatusListener>>();
+
   // Whether context-level stealth init script has been installed
   private _contextStealthInstalled = false;
 
@@ -163,7 +171,7 @@ export class BrowserSession {
   private readonly _uaOverrideApplied = new Set<string>();
 
   // Serialization lock for tab-switching operations
-  private _lockQueue: Array<() => void> = [];
+  private _lockQueue: Array<{ grant: () => void; settled: boolean }> = [];
   private _locked = false;
 
   // Currently screencast conversation (only one at a time due to CDP)
@@ -189,19 +197,38 @@ export class BrowserSession {
       return;
     }
     return new Promise<void>((resolve, reject) => {
+      const waiter = { settled: false, grant: () => {} };
       const timer = setTimeout(() => {
-        const idx = this._lockQueue.indexOf(resolve);
+        if (waiter.settled) return;
+        waiter.settled = true;
+        const idx = this._lockQueue.indexOf(waiter);
         if (idx !== -1) this._lockQueue.splice(idx, 1);
         reject(new Error("Browser operation timed out waiting for lock (30s)"));
       }, 30_000);
-      this._lockQueue.push(() => { clearTimeout(timer); resolve(); });
+      waiter.grant = () => {
+        if (waiter.settled) return;
+        waiter.settled = true;
+        clearTimeout(timer);
+        resolve();
+      };
+      this._lockQueue.push(waiter);
     });
   }
 
   private unlock(): void {
-    const next = this._lockQueue.shift();
-    if (next) next();
-    else this._locked = false;
+    // Hand ownership to the next waiter that is still live. A waiter whose
+    // 30s timeout already fired has rejected its promise and marked itself
+    // settled; granting it would silently drop the lock (resolve is a no-op)
+    // and leave `_locked` true forever, wedging every later caller. Skip the
+    // dead ones; if none remain, release the lock.
+    while (this._lockQueue.length > 0) {
+      const next = this._lockQueue.shift()!;
+      if (!next.settled) {
+        next.grant();
+        return;
+      }
+    }
+    this._locked = false;
   }
 
   // -----------------------------------------------------------------------
@@ -481,13 +508,10 @@ export class BrowserSession {
       if (realTabs > 0) {
         await mgr.newTab();
       }
-      const existing = tab;
       tab = {
         tabIndex: mgr.getActiveIndex(),
         active: true,
         lastUsed: Date.now(),
-        frameListeners: existing?.frameListeners ?? new Set(),
-        statusListeners: existing?.statusListeners ?? new Set(),
       };
       this.tabs.set(conversationId, tab);
     } else {
@@ -780,15 +804,15 @@ export class BrowserSession {
         (frame) => {
           const cid = this._screencastConversation;
           if (!cid) return;
-          const t = this.tabs.get(cid);
-          if (!t) return;
+          const listeners = this.frameListeners.get(cid);
+          if (!listeners || listeners.size === 0) return;
           const browserFrame: BrowserFrame = {
             data: frame.data,
             width: frame.metadata.deviceWidth,
             height: frame.metadata.deviceHeight,
             timestamp: Date.now(),
           };
-          for (const listener of t.frameListeners) {
+          for (const listener of listeners) {
             try { listener(browserFrame); } catch { /* */ }
           }
         },
@@ -816,28 +840,38 @@ export class BrowserSession {
   // -----------------------------------------------------------------------
 
   onFrame(conversationId: string, listener: FrameListener): () => void {
-    let tab = this.tabs.get(conversationId);
-    if (!tab) {
-      tab = { tabIndex: -1, active: false, lastUsed: Date.now(), frameListeners: new Set(), statusListeners: new Set() };
-      this.tabs.set(conversationId, tab);
+    let set = this.frameListeners.get(conversationId);
+    if (!set) {
+      set = new Set();
+      this.frameListeners.set(conversationId, set);
     }
-    tab.frameListeners.add(listener);
+    set.add(listener);
     return () => {
-      tab!.frameListeners.delete(listener);
-      if (tab!.frameListeners.size === 0 && this._screencastConversation === conversationId) {
-        this.stopScreencast().catch(() => {});
+      const s = this.frameListeners.get(conversationId);
+      if (!s) return;
+      s.delete(listener);
+      if (s.size === 0) {
+        this.frameListeners.delete(conversationId);
+        if (this._screencastConversation === conversationId) {
+          this.stopScreencast().catch(() => {});
+        }
       }
     };
   }
 
   onStatus(conversationId: string, listener: StatusListener): () => void {
-    let tab = this.tabs.get(conversationId);
-    if (!tab) {
-      tab = { tabIndex: -1, active: false, lastUsed: Date.now(), frameListeners: new Set(), statusListeners: new Set() };
-      this.tabs.set(conversationId, tab);
+    let set = this.statusListeners.get(conversationId);
+    if (!set) {
+      set = new Set();
+      this.statusListeners.set(conversationId, set);
     }
-    tab.statusListeners.add(listener);
-    return () => { tab!.statusListeners.delete(listener); };
+    set.add(listener);
+    return () => {
+      const s = this.statusListeners.get(conversationId);
+      if (!s) return;
+      s.delete(listener);
+      if (s.size === 0) this.statusListeners.delete(conversationId);
+    };
   }
 
   // -----------------------------------------------------------------------
@@ -1049,8 +1083,12 @@ export class BrowserSession {
       url: tab?.url,
       interactionAllowed: tab?.active ?? false,
     };
-    if (tab) {
-      for (const listener of tab.statusListeners) {
+    // Listeners live at the session level, so a close (which deletes the tab)
+    // still delivers the final active:false to the host before the tab is
+    // gone — and a later reopen reuses the same subscription.
+    const listeners = this.statusListeners.get(conversationId);
+    if (listeners) {
+      for (const listener of listeners) {
         try { listener(status); } catch { /* */ }
       }
     }