@poncho-ai/browser 0.6.24 → 0.6.25

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.25 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.44 KB
+ESM ⚡️ Build success in 63ms
 DTS Build start
-DTS ⚡️ Build success in 5077ms
+DTS ⚡️ Build success in 5080ms
 DTS dist/index.d.ts 13.69 KB

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @poncho-ai/browser
 
+## 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.js

@@ -275,21 +275,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

package/package.json

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

package/src/session.ts

@@ -163,7 +163,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 +189,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;
   }
 
   // -----------------------------------------------------------------------