High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
fix(bridge): freeze_idle is re-armed by every access and held off while a request runs, a wedged tab cannot block other thaws, and a failed thaw fails the request (PIN-369)
Luigi Agostib710587b19cf
diff --git a/dashboard/src/pages/settings/DefaultsSettingsSection.tsx b/dashboard/src/pages/settings/DefaultsSettingsSection.tsxindex 3e9b9048..33fea708 100644--- a/dashboard/src/pages/settings/DefaultsSettingsSection.tsx+++ b/dashboard/src/pages/settings/DefaultsSettingsSection.tsx@@ -142,7 +142,7 @@ export function DefaultsSettingsSection({</SettingRow><SettingRowlabel="Tab lifecycle"- description="Optionally close or freeze idle tabs after a /text, /snapshot, or /action response. The timer resets on each subsequent request and is cancelled by /navigate; a frozen tab unfreezes on its next request."+ description="Close idle closes a tab after a /text, /snapshot, or /action response once the delay passes; /navigate cancels it. Freeze idle freezes any tab no request has touched for the delay and unfreezes it on its next request."><Selectvalue={backendConfig.instanceDefaults.tabPolicy?.lifecycle ?? "keep"}diff --git a/docs/core-concepts.md b/docs/core-concepts.mdindex e7ea6ef9..62ea68a1 100644--- a/docs/core-concepts.md+++ b/docs/core-concepts.md@@ -193,10 +193,12 @@ curl -X POST http://localhost:9867/close \By default, tabs use the `keep` lifecycle policy and are not auto-closed afterreads or actions. Set `instanceDefaults.tabPolicy.lifecycle` to `close_idle` toauto-close a tab after an authorized `/text`, `/snapshot`, or `/action` request-finishes. Set it to `freeze_idle` to freeze the tab instead: its timers and-JavaScript stop, while its DOM, session and URL survive, and the next request-that touches the tab unfreezes it before running. A tab paused for handoff,-streaming a screencast, or holding network interception rules is never frozen.+finishes. Set it to `freeze_idle` to freeze a tab that no request has touched+for the idle delay instead: its timers and JavaScript stop, while its DOM,+session and URL survive. Every request on the tab restarts that clock and+unfreezes the tab before running, and a tab is never frozen while a request on+it is still running (a screencast stream counts), while it is paused for+handoff, or while it holds network interception rules.`instanceDefaults.tabPolicy.closeDelaySec` adjusts the idle delay when`close_idle` or `freeze_idle` is enabled.diff --git a/docs/reference/config.md b/docs/reference/config.mdindex 022bfa52..5029c6fe 100644--- a/docs/reference/config.md+++ b/docs/reference/config.md@@ -511,7 +511,7 @@ You can change or clear that default with `browser.extensionPaths`.```- `eviction` controls what happens when `maxTabs` is reached: `close_lru`, `close_oldest`, or `reject`.-- `lifecycle` controls idle lifecycle behavior: `keep` disables lifecycle auto-close and is the default; `close_idle` auto-closes a tab after it handles an authorized `/text`, `/snapshot`, or `/action` request; `freeze_idle` freezes it at the same point instead (timers and JavaScript stop, the page and session stay), and any later request on the tab unfreezes it first. Tabs paused for handoff, streaming a screencast, or holding network interception rules are never frozen.+- `lifecycle` controls idle lifecycle behavior: `keep` disables lifecycle auto-close and is the default; `close_idle` auto-closes a tab after it handles an authorized `/text`, `/snapshot`, or `/action` request; `freeze_idle` instead freezes a tab no request has touched for the idle delay (timers and JavaScript stop, the page and session stay); every request restarts that clock and unfreezes the tab first. A tab is never frozen while a request on it is running (including a screencast stream), while it is paused for handoff, or while it holds network interception rules.- `closeDelaySec` is the idle delay for `close_idle` and `freeze_idle`. The default is `300` seconds when either is enabled.- `restore` controls whether session tabs are restored on startup. The default is `false`.diff --git a/internal/bridge/bridge_test.go b/internal/bridge/bridge_test.goindex 45ee8be5..cd2bca28 100644--- a/internal/bridge/bridge_test.go+++ b/internal/bridge/bridge_test.go@@ -291,7 +291,9 @@ func TestMarkAccessedUpdatesCurrentTabAndLastUsed(t *testing.T) {tm.tabs["tab2"] = &TabEntry{Ctx: context.Background(), CreatedAt: oldTime, LastUsed: oldTime}tm.currentTab = "tab1"- tm.markAccessed("tab2")+ if err := tm.markAccessed("tab2"); err != nil {+ t.Fatal(err)+ }if tm.currentTab != "tab2" {t.Fatalf("currentTab = %q, want tab2", tm.currentTab)diff --git a/internal/bridge/bridge_types.go b/internal/bridge/bridge_types.goindex 19967bc2..a0ef988e 100644--- a/internal/bridge/bridge_types.go+++ b/internal/bridge/bridge_types.go@@ -5,6 +5,7 @@ import ("fmt""net""strconv"+ "sync""time""github.com/pinchtab/pinchtab/internal/browserops"@@ -25,10 +26,11 @@ type TabEntry struct {CreatorScope stringUsedByOtherScope bool- idleTimer *time.Timer- idleGen uint64- frozen bool- awakeHolds int+ idleTimer *time.Timer+ idleGen uint64+ frozen bool+ awakeHolds int+ lifecycleMu sync.Mutex}type RefTarget struct {diff --git a/internal/bridge/screencast.go b/internal/bridge/screencast.goindex 55039c61..da9ac740 100644--- a/internal/bridge/screencast.go+++ b/internal/bridge/screencast.go@@ -23,29 +23,10 @@ import (// mode. Polling is used for headless browsers and providers whose CDP proxy// does not support Page.startScreencast (e.g. Cloak).func (b *Bridge) StartScreencast(ctx context.Context, opts ScreencastOpts) (*ScreencastStream, error) {- release := b.holdTabAwake(ctx)- start := b.startScreencastEventDrivenif b.shouldUsePollingScreencast() {- start = b.startScreencastPolling+ return b.startScreencastPolling(ctx, opts)}- stream, err := start(ctx, opts)- if err != nil {- release()- return nil, err- }- go func() {- <-stream.Done()- release()- }()- return stream, nil-}--func (b *Bridge) holdTabAwake(ctx context.Context) (release func()) {- c := chromedp.FromContext(ctx)- if b.TabManager == nil || c == nil || c.Target == nil {- return func() {}- }- return b.HoldAwake(b.IdMgr.TabIDFromCDPTarget(string(c.Target.TargetID)))+ return b.startScreencastEventDriven(ctx, opts)}func (b *Bridge) shouldUsePollingScreencast() bool {diff --git a/internal/bridge/tab_adopt.go b/internal/bridge/tab_adopt.goindex b55a2a57..83341c6b 100644--- a/internal/bridge/tab_adopt.go+++ b/internal/bridge/tab_adopt.go@@ -123,7 +123,9 @@ func (tm *TabManager) adoptExistingTarget(targetID target.ID, enforceLimit bool)if entry == nil || entry.Ctx == nil {return "", fmt.Errorf("tab %s has no active context", tabID)}- tm.touchTab(tabID)+ if err := tm.touchTab(tabID); err != nil {+ return "", err+ }return tabID, nil}diff --git a/internal/bridge/tab_freeze.go b/internal/bridge/tab_freeze.goindex 2cd0117e..2fc47973 100644--- a/internal/bridge/tab_freeze.go+++ b/internal/bridge/tab_freeze.go@@ -2,19 +2,29 @@ package bridgeimport ("context"+ "fmt""log/slog"+ "sync""time""github.com/chromedp/chromedp""github.com/pinchtab/pinchtab/internal/bridge/cdpops")+const lifecycleCallTimeout = 5 * time.Second+func setTabFrozen(ctx context.Context, frozen bool) error {return chromedp.Run(ctx, chromedp.ActionFunc(func(c context.Context) error {return cdpops.SetPageFrozen(c, frozen)}))}+func (tm *TabManager) applyFrozen(tabCtx context.Context, frozen bool) error {+ ctx, cancel := context.WithTimeout(tabCtx, lifecycleCallTimeout)+ defer cancel()+ return tm.setFrozen(ctx, frozen)+}+func (tm *TabManager) SetFreezeVeto(veto func(tabID string) bool) {tm.freezeVeto = veto}@@ -36,11 +46,25 @@ func (tm *TabManager) HoldAwake(tabID string) (release func()) {if !ok {return func() {}}+ var once sync.Oncereturn func() {- tm.mu.Lock()- entry.awakeHolds--- tm.mu.Unlock()+ once.Do(func() {+ tm.mu.Lock()+ entry.awakeHolds--+ idle := entry.awakeHolds == 0+ tm.mu.Unlock()+ if idle {+ tm.rearmFreeze(tabID)+ }+ })+ }+}++func (tm *TabManager) HoldAwakeUntil(ctx context.Context, tabID string) {+ if tm == nil || !tm.freezesIdleTabs() {+ return}+ context.AfterFunc(ctx, tm.HoldAwake(tabID))}func (tm *TabManager) TabFrozen(tabID string) bool {@@ -50,16 +74,27 @@ func (tm *TabManager) TabFrozen(tabID string) bool {return ok && entry.frozen}+func (tm *TabManager) rearmFreeze(tabID string) {+ if tm.freezesIdleTabs() {+ tm.ScheduleIdleLifecycle(tabID)+ }+}+func (tm *TabManager) freezeIdleTab(tabID string, gen uint64) {if tm.keepsAwake(tabID) {return}- tm.lifecycleMu.Lock()- defer tm.lifecycleMu.Unlock()+ tm.mu.RLock()+ entry, ok := tm.tabs[tabID]+ tm.mu.RUnlock()+ if !ok {+ return+ }+ entry.lifecycleMu.Lock()+ defer entry.lifecycleMu.Unlock()tm.mu.Lock()- entry, ok := tm.tabs[tabID]- if !ok || entry.idleGen != gen || entry.Ctx == nil || entry.awakeHolds > 0 {+ if entry.idleGen != gen || entry.Ctx == nil || entry.awakeHolds > 0 {tm.mu.Unlock()return}@@ -68,49 +103,43 @@ func (tm *TabManager) freezeIdleTab(tabID string, gen uint64) {ctx := entry.Ctxtm.mu.Unlock()- if err := tm.setFrozen(ctx, true); err != nil {- tm.mu.Lock()- entry.frozen = false- tm.mu.Unlock()+ if err := tm.applyFrozen(ctx, true); err != nil {slog.Debug("freeze idle tab failed", "tabId", tabID, "err", err)return}slog.Info("tab frozen", "tabId", tabID, "reason", "freeze_idle")}-func (tm *TabManager) thawTab(tabID string) {- tm.lifecycleMu.Lock()- defer tm.lifecycleMu.Unlock()+func (tm *TabManager) thawTab(tabID string, entry *TabEntry) error {+ entry.lifecycleMu.Lock()+ defer entry.lifecycleMu.Unlock()- tm.mu.Lock()- entry, ok := tm.tabs[tabID]- if !ok || !entry.frozen {- tm.mu.Unlock()- return+ tm.mu.RLock()+ frozen, ctx := entry.frozen, entry.Ctx+ tm.mu.RUnlock()+ if !frozen {+ return nil+ }+ if err := tm.applyFrozen(ctx, false); err != nil {+ return fmt.Errorf("tab %s could not be unfrozen: %w", tabID, err)}+ tm.mu.Lock()entry.frozen = false- ctx := entry.Ctxtm.mu.Unlock()-- if err := tm.setFrozen(ctx, false); err != nil {- slog.Warn("unfreeze tab failed", "tabId", tabID, "err", err)- }+ return nil}-func (tm *TabManager) touchTab(tabID string) {+func (tm *TabManager) touchTab(tabID string) error {tm.mu.Lock()tm.accessed[tabID] = trueentry, ok := tm.tabs[tabID]- frozen := falseif ok {entry.LastUsed = time.Now()- if tm.freezesIdleTabs() {- entry.stopIdleTimer()- }- frozen = entry.frozen}tm.mu.Unlock()- if frozen {- tm.thawTab(tabID)+ if !ok {+ return nil}+ tm.rearmFreeze(tabID)+ return tm.thawTab(tabID, entry)}diff --git a/internal/bridge/tab_freeze_browser_test.go b/internal/bridge/tab_freeze_browser_test.goindex 8158c21f..a59babd7 100644--- a/internal/bridge/tab_freeze_browser_test.go+++ b/internal/bridge/tab_freeze_browser_test.go@@ -9,7 +9,6 @@ import ("github.com/chromedp/cdproto/target""github.com/chromedp/chromedp""github.com/pinchtab/pinchtab/internal/config"- "github.com/pinchtab/pinchtab/internal/ids""github.com/pinchtab/pinchtab/internal/testbrowser")@@ -54,13 +53,6 @@ func TestFreezeIdleFreezesARealTabAndAnActionUnfreezesIt(t *testing.T) {tabID := string(raw)tm.tabs[tabID] = &TabEntry{Ctx: tabCtx, CDPID: tabID, CreatedAt: time.Now(), LastUsed: time.Now()}- b := &Bridge{TabManager: tm, IdMgr: ids.NewManager()}- release := b.holdTabAwake(tabCtx)- if tm.tabs[tabID].awakeHolds != 1 {- t.Fatal("a screencast on the tab context did not hold the tab awake")- }- release()-tm.ScheduleIdleLifecycle(tabID)deadline := time.Now().Add(5 * time.Second)for !tm.TabFrozen(tabID) && time.Now().Before(deadline) {diff --git a/internal/bridge/tab_freeze_test.go b/internal/bridge/tab_freeze_test.goindex b6ec49fd..e70d66da 100644--- a/internal/bridge/tab_freeze_test.go+++ b/internal/bridge/tab_freeze_test.go@@ -2,6 +2,9 @@ package bridgeimport ("context"+ "errors"+ "reflect"+ "strings""sync""testing""time"@@ -51,6 +54,14 @@ func frozenOrTimeout(tm *TabManager, want bool, within time.Duration) bool {return tm.TabFrozen("tab1") == want}+func (r *frozenRecorder) awaitCalls(n int) []bool {+ deadline := time.Now().Add(time.Second)+ for len(r.snapshot()) < n && time.Now().Before(deadline) {+ time.Sleep(5 * time.Millisecond)+ }+ return r.snapshot()+}+func freezeNow(t *testing.T, tm *TabManager) {t.Helper()tm.mu.RLock()@@ -67,10 +78,7 @@ func TestFreezeIdleFreezesTheTabAfterTheDelay(t *testing.T) {tm.ScheduleIdleLifecycle("tab1")- if !frozenOrTimeout(tm, true, time.Second) {- t.Fatal("tab was not frozen after closeDelay")- }- if got := rec.snapshot(); len(got) != 1 || !got[0] {+ if got := rec.awaitCalls(1); len(got) != 1 || !got[0] || !tm.TabFrozen("tab1") {t.Fatalf("lifecycle calls = %v, want [frozen]", got)}if _, ok := tm.tabs["tab1"]; !ok {@@ -123,17 +131,128 @@ func TestEveryAccessPathUnfreezesAFrozenTab(t *testing.T) {}}-func TestAccessCancelsAPendingFreeze(t *testing.T) {+func TestAnAccessRearmsTheFreeze(t *testing.T) {tm, rec := newFreezeTM(t, "freeze_idle", 30*time.Millisecond)- tm.ScheduleIdleLifecycle("tab1")+ freezeNow(t, tm)++ if _, _, err := tm.TabContext("tab1"); err != nil {+ t.Fatalf("access: %v", err)+ }++ if got := rec.awaitCalls(3); !reflect.DeepEqual(got, []bool{true, false, true}) || !tm.TabFrozen("tab1") {+ t.Fatalf("lifecycle calls = %v, want [frozen active frozen]", got)+ }+}++func TestALoneAccessArmsTheFreeze(t *testing.T) {+ tm, _ := newFreezeTM(t, "freeze_idle", 20*time.Millisecond)if _, _, err := tm.TabContext("tab1"); err != nil {t.Fatalf("access: %v", err)}- time.Sleep(90 * time.Millisecond)++ if !frozenOrTimeout(tm, true, time.Second) {+ t.Fatal("an accessed tab never froze")+ }+}++func TestARequestHoldKeepsTheTabAwakeUntilTheRequestEnds(t *testing.T) {+ tm, rec := newFreezeTM(t, "freeze_idle", 20*time.Millisecond)+ req, endRequest := context.WithCancel(context.Background())+ tm.HoldAwakeUntil(req, "tab1")+ tm.ScheduleIdleLifecycle("tab1")++ time.Sleep(80 * time.Millisecond)+ if got := rec.snapshot(); len(got) != 0 {+ t.Fatalf("tab frozen while a request held it: %v", got)+ }++ endRequest()+ if !frozenOrTimeout(tm, true, time.Second) {+ t.Fatal("tab never froze after the request ended")+ }+}++func TestReleasingAHoldTwiceDoesNotDropAnotherHold(t *testing.T) {+ tm, rec := newFreezeTM(t, "freeze_idle", 10*time.Millisecond)+ first := tm.HoldAwake("tab1")+ tm.HoldAwake("tab1")++ first()+ first()+ tm.ScheduleIdleLifecycle("tab1")+ time.Sleep(60 * time.Millisecond)if got := rec.snapshot(); len(got) != 0 {- t.Fatalf("a tab in use was frozen: %v", got)+ t.Fatalf("tab frozen under a live hold: %v", got)+ }+}++type tabKey struct{}++func TestAWedgedTabDoesNotBlockAnotherTabsThaw(t *testing.T) {+ tm, _ := newFreezeTM(t, "freeze_idle", time.Hour)+ wedged := make(chan struct{})+ entered := make(chan bool, 1)+ defer close(wedged)+ tm.setFrozen = func(ctx context.Context, frozen bool) error {+ if ctx.Value(tabKey{}) == "A" {+ _, bounded := ctx.Deadline()+ entered <- bounded+ <-wedged+ }+ return nil+ }+ for _, id := range []string{"tabA", "tabB"} {+ tm.tabs[id] = &TabEntry{Ctx: context.WithValue(context.Background(), tabKey{}, id[3:]), frozen: true}+ }++ go func() { _, _, _ = tm.TabContext("tabA") }()+ if bounded := <-entered; !bounded {+ t.Fatal("the lifecycle call runs without a deadline")+ }++ done := make(chan error, 1)+ go func() { _, _, err := tm.TabContext("tabB"); done <- err }()+ select {+ case err := <-done:+ if err != nil || tm.TabFrozen("tabB") {+ t.Fatalf("thaw of tabB: err=%v frozen=%v", err, tm.TabFrozen("tabB"))+ }+ case <-time.After(time.Second):+ t.Fatal("a wedged tabA blocked the thaw of tabB")+ }+}++func TestAFailedThawFailsTheRequestAndTheNextAccessRetries(t *testing.T) {+ tm, rec := newFreezeTM(t, "freeze_idle", time.Hour)+ freezeNow(t, tm)+ fail := true+ tm.setFrozen = func(ctx context.Context, frozen bool) error {+ _ = rec.set(ctx, frozen)+ if fail {+ fail = false+ return errors.New("renderer busy")+ }+ return nil+ }++ _, _, err := tm.TabContext("tab1")+ if err == nil || !strings.Contains(err.Error(), "could not be unfrozen") {+ t.Fatalf("first access err = %v, want could not be unfrozen", err)+ }+ if !tm.TabFrozen("tab1") {+ t.Fatal("a failed thaw was recorded as awake")+ }++ if _, _, err := tm.TabContext("tab1"); err != nil {+ t.Fatalf("retry: %v", err)+ }+ if tm.TabFrozen("tab1") {+ t.Fatal("tab still frozen after a successful retry")+ }+ if got := rec.snapshot(); len(got) != 3 || got[1] || got[2] {+ t.Fatalf("lifecycle calls = %v, want [frozen active active]", got)}}@@ -147,8 +266,8 @@ func TestTabsDoingUnpolledWorkAreNeverFrozen(t *testing.T) {t.Fatal(err)}}},- {"screencast streaming", func(t *testing.T, b *Bridge) {- t.Cleanup(b.HoldAwake("tab1"))+ {"request in flight, such as a screencast stream", func(t *testing.T, b *Bridge) {+ b.HoldAwakeUntil(t.Context(), "tab1")}},{"network interception rules", func(t *testing.T, b *Bridge) {b.routeMgr.mu.Lock()@@ -174,15 +293,3 @@ func TestTabsDoingUnpolledWorkAreNeverFrozen(t *testing.T) {})}}--func TestReleasedScreencastHoldLetsTheTabFreeze(t *testing.T) {- tm, _ := newFreezeTM(t, "freeze_idle", 10*time.Millisecond)- release := tm.HoldAwake("tab1")- release()-- tm.ScheduleIdleLifecycle("tab1")-- if !frozenOrTimeout(tm, true, time.Second) {- t.Fatal("tab never froze after the hold was released")- }-}diff --git a/internal/bridge/tab_lookup.go b/internal/bridge/tab_lookup.goindex 37591f77..3bf30ae8 100644--- a/internal/bridge/tab_lookup.go+++ b/internal/bridge/tab_lookup.go@@ -9,11 +9,11 @@ import ("github.com/chromedp/cdproto/target")-func (tm *TabManager) markAccessed(tabID string) {- tm.touchTab(tabID)+func (tm *TabManager) markAccessed(tabID string) error {tm.mu.Lock()tm.currentTab = tabIDtm.mu.Unlock()+ return tm.touchTab(tabID)}func (tm *TabManager) CurrentTabID() string {@@ -128,8 +128,9 @@ func (tm *TabManager) TabContext(tabID string) (context.Context, string, error)return nil, "", fmt.Errorf("tab %s has no active context", tabID)}- tm.markAccessed(tabID)-+ if err := tm.markAccessed(tabID); err != nil {+ return nil, "", err+ }return entry.Ctx, tabID, nil}diff --git a/internal/bridge/tab_manager.go b/internal/bridge/tab_manager.goindex 9d5a2cc5..9d0da3ed 100644--- a/internal/bridge/tab_manager.go+++ b/internal/bridge/tab_manager.go@@ -50,7 +50,6 @@ type TabManager struct {guardOnce sync.OnceguardActive boolmu sync.RWMutex- lifecycleMu sync.MutexfreezeVeto func(tabID string) boolsetFrozen func(ctx context.Context, frozen bool) errordiff --git a/internal/handlers/actions_test.go b/internal/handlers/actions_test.goindex dc02f25f..659b363a 100644--- a/internal/handlers/actions_test.go+++ b/internal/handlers/actions_test.go@@ -481,8 +481,8 @@ func TestHandleAction_AutoCloseArmedAfterActionError(t *testing.T) {}}-func TestHandleAction_IdleLifecycleArmedUnderEveryIdlePolicy(t *testing.T) {- for _, policy := range []string{"close_idle", "freeze_idle"} {+func TestHandleAction_OnlyCloseIdleIsArmedByTheHandler(t *testing.T) {+ for policy, want := range map[string]int{"close_idle": 1, "freeze_idle": 0, "keep": 0} {t.Run(policy, func(t *testing.T) {mb := &mockBridge{}h := New(mb, &config.RuntimeConfig{ActionTimeout: time.Second, TabLifecyclePolicy: policy}, nil, nil, nil)@@ -490,8 +490,8 @@ func TestHandleAction_IdleLifecycleArmedUnderEveryIdlePolicy(t *testing.T) {h.HandleAction(httptest.NewRecorder(), req)- if got := mb.autoCloseArmed; len(got) != 1 || got[0] != "tab1" {- t.Fatalf("idle timer armed for %#v, want [tab1]", got)+ if got := len(mb.autoCloseArmed); got != want {+ t.Fatalf("handler armed the idle timer %d times, want %d", got, want)}})}diff --git a/internal/handlers/activity_helpers.go b/internal/handlers/activity_helpers.goindex 8416bff6..809ca823 100644--- a/internal/handlers/activity_helpers.go+++ b/internal/handlers/activity_helpers.go@@ -28,6 +28,7 @@ func (h *Handlers) tabContext(r *http.Request, tabID string) (context.Context, sreturn nil, "", noCurrentTabError(scope.Description())}if err == nil {+ h.holdTabAwakeForRequest(r, resolvedID)h.setCurrentTabForRequest(r, resolvedID)h.recordActivity(r, activity.Update{TabID: resolvedID})}@@ -80,6 +81,18 @@ func (h *Handlers) recordResolvedTab(r *http.Request, tabID string) {h.recordActivity(r, activity.Update{TabID: tabID})}+type tabAwakeHolder interface {+ HoldAwakeUntil(ctx context.Context, tabID string)+}++var _ tabAwakeHolder = (*bridge.Bridge)(nil)++func (h *Handlers) holdTabAwakeForRequest(r *http.Request, tabID string) {+ if holder, ok := h.Bridge.(tabAwakeHolder); ok {+ holder.HoldAwakeUntil(r.Context(), tabID)+ }+}+type tabScopeTracker interface {RecordTabScope(tabID, scope string, created bool)TabsOnlyUsedByCreator(scope string) []stringdiff --git a/internal/handlers/handlers.go b/internal/handlers/handlers.goindex 67b70f23..56f83ed9 100644--- a/internal/handlers/handlers.go+++ b/internal/handlers/handlers.go@@ -237,19 +237,19 @@ func (h *Handlers) ensureBrowserOrRespond(w http.ResponseWriter, cfg *config.Run}func (h *Handlers) armIdleLifecycle(tabID string) {- if h.idleLifecycleActive(tabID) {+ if h.closesIdleTabs(tabID) {h.Bridge.ScheduleIdleLifecycle(tabID)}}func (h *Handlers) cancelIdleLifecycle(tabID string) {- if h.idleLifecycleActive(tabID) {+ if h.closesIdleTabs(tabID) {h.Bridge.CancelIdleLifecycle(tabID)}}-func (h *Handlers) idleLifecycleActive(tabID string) bool {- return h != nil && h.Bridge != nil && tabID != "" && h.Config != nil && config.IdleTabLifecycle(h.Config.TabLifecyclePolicy)+func (h *Handlers) closesIdleTabs(tabID string) bool {+ return h != nil && h.Bridge != nil && tabID != "" && h.Config != nil && h.Config.TabLifecyclePolicy == "close_idle"}// clearTabFrameScope drops any active frame scope on a tab. Call fromdiff --git a/internal/handlers/tab_awake_hold_test.go b/internal/handlers/tab_awake_hold_test.gonew file mode 100644index 00000000..a398b773--- /dev/null+++ b/internal/handlers/tab_awake_hold_test.go@@ -0,0 +1,53 @@+package handlers++import (+ "context"+ "net/http/httptest"+ "testing"+ "time"++ "github.com/chromedp/chromedp"+ "github.com/pinchtab/pinchtab/internal/bridge"+ "github.com/pinchtab/pinchtab/internal/config"+ "github.com/pinchtab/pinchtab/internal/testbrowser"+)++func TestATabResolvedForARequestStaysAwakeUntilTheRequestEnds(t *testing.T) {+ alloc, cancelAlloc := chromedp.NewExecAllocator(context.Background(), append(+ chromedp.DefaultExecAllocatorOptions[:],+ chromedp.ExecPath(testbrowser.Path(t)),+ chromedp.UserDataDir(testbrowser.ProfileDir(t)),+ chromedp.Flag("headless", true),+ chromedp.Flag("no-sandbox", true),+ )...)+ t.Cleanup(cancelAlloc)+ tabCtx, cancelTab := chromedp.NewContext(alloc)+ t.Cleanup(cancelTab)+ if err := chromedp.Run(tabCtx); err != nil {+ t.Fatalf("start browser: %v", err)+ }+ cfg := &config.RuntimeConfig{TabLifecyclePolicy: "freeze_idle", TabCloseDelay: 20 * time.Millisecond, StateDir: t.TempDir()}+ b := bridge.New(context.Background(), tabCtx, cfg)+ b.RegisterTab("tabA", tabCtx)+ h := New(b, cfg, nil, nil, nil)++ reqCtx, endRequest := context.WithCancel(context.Background())+ req := httptest.NewRequest("GET", "/snapshot", nil).WithContext(reqCtx)+ if _, _, err := h.tabContext(req, "tabA"); err != nil {+ t.Fatalf("resolve tab: %v", err)+ }++ time.Sleep(80 * time.Millisecond)+ if b.TabFrozen("tabA") {+ t.Fatal("tab froze while its request was still running")+ }++ endRequest()+ deadline := time.Now().Add(time.Second)+ for !b.TabFrozen("tabA") && time.Now().Before(deadline) {+ time.Sleep(5 * time.Millisecond)+ }+ if !b.TabFrozen("tabA") {+ t.Fatal("tab never froze after its request ended")+ }+}