Browser profile management: use browser-use style profile handling

[wu-changxing]

Problem

When BrowserAutomation runs inside co ai (uvicorn async server), the browser profile causes two issues:

1. SingletonLock conflict — ~/.co/browser_profile/SingletonLock persists after crashes or between sessions, blocking new browser launches with "Failed to create a ProcessSingleton for your profile directory"

2. Sync Playwright inside async loop — sync_playwright() fails with "Playwright Sync API inside the asyncio loop" when called from uvicorn's event loop context on subsequent sessions

The current approach uses launch_persistent_context() with a shared Chrome profile at ~/.co/browser_profile/, which conflicts with the user's running Chrome and doesn't handle concurrent/sequential sessions cleanly.

Proposal

Adopt the same profile management approach as browser-use — proper profile isolation, cleanup, and async-compatible browser lifecycle.

Current behavior

• First session: browser works (runs in asyncio.to_thread)
• Second session: SingletonLock from first session blocks launch
• After lock error: falls back to sync_playwright() which fails in async context
• No cleanup on agent shutdown

Logs

BrowserType.launch_persistent_context: Failed to create a ProcessSingleton for your profile directory.
...
Error: It looks like you are using Playwright Sync API inside the asyncio loop.
Please use the Async API instead.

[wu-changxing]

🔍 Summary

BrowserAutomation uses sync_playwright() + launch_persistent_context() with a shared profile at ~/.co/browser_profile/. When running inside co ai's uvicorn server, the SingletonLock persists across sessions (blocking relaunches) and sync_playwright() fails on subsequent calls inside the async event loop. Fix by adopting browser-use's profile isolation pattern: temp profile per session with optional copy from persistent profile, lazy init, proper cleanup, and async-compatible launch.

📊 Current vs Proposed

CURRENT (Broken in async server):
┌──────────────┐
│  co ai host  │  (uvicorn async loop)
└──────┬───────┘
       │ create_coding_agent()
       ▼
┌──────────────┐     ┌──────────────────────────┐
│ BrowserAuto  │────▶│ ~/.co/browser_profile/   │ ← Shared, locked
│ sync_play()  │     │  SingletonLock ❌         │
└──────────────┘     └──────────────────────────┘
       │
       │ 2nd session
       ▼
  ❌ SingletonLock blocks launch
  ❌ sync_playwright() inside async loop


PROPOSED (Isolated sessions):
┌──────────────┐
│  co ai host  │  (uvicorn async loop)
└──────┬───────┘
       │ create_coding_agent()
       ▼
┌──────────────┐     ┌──────────────────────────┐
│ BrowserAuto  │     │ ~/.co/browser_profile/   │ ← Persistent (source)
│  (lazy init) │     │  cookies, localStorage   │
└──────┬───────┘     └────────────┬─────────────┘
       │ open_browser()            │ copy profile
       ▼                           ▼
┌──────────────┐     ┌──────────────────────────┐
│ Playwright   │────▶│ /tmp/co-browser-XXXXX/   │ ← Temp, isolated
│ launch()     │     │  No SingletonLock issue   │
└──────┬───────┘     └──────────────────────────┘
       │
       │ close()
       ▼
  ✅ Copy cookies BACK to persistent profile
  ✅ Delete temp dir
  ✅ No lock conflicts

🔄 Browser Lifecycle (New)

BrowserAutomation.__init__()
     │
     │  (no browser launched — lazy)
     ▼
open_browser() / go_to()  ← first tool call triggers init
     │
     ├─ 1. Create temp profile dir: /tmp/co-browser-{uuid}/
     │
     ├─ 2. Copy from persistent? ─── YES ──▶ shutil.copytree(
     │     (~/.co/browser_profile         ~/.co/browser_profile/Default,
     │      exists and non-empty?)         temp_dir/Default)
     │           │                        + copy Local State file
     │           NO
     │           │
     │           ▼
     │     Fresh temp dir (first run)
     │
     ├─ 3. launch_persistent_context(temp_dir, ...)
     │      ✅ No SingletonLock on shared profile
     │      ✅ Each session gets own copy
     │
     ├─ 4. On SingletonLock error (retry):
     │      Create NEW temp dir, retry up to 3 times
     │
     ▼
  [Browser session active — tools work normally]
     │
close()
     │
     ├─ 5. Save context (wait 500ms)
     ├─ 6. Copy cookies/state BACK to persistent profile
     │      (so next session inherits login state)
     ├─ 7. Close browser + playwright
     └─ 8. Delete temp dir (cleanup)

📁 Files to Change

connectonion/useful_tools/browser_tools/
├── browser.py          ← MODIFY: Profile isolation + cleanup + retry
├── browser_config.py   ← NO CHANGE (keep existing args)
├── element_finder.py   ← NO CHANGE
├── scroll.py           ← NO CHANGE
└── __init__.py         ← NO CHANGE

Only ONE file changes: browser.py. Everything else stays the same.

🏗️ Architecture Changes in browser.py

class BrowserAutomation:
    │
    ├── __init__(headless, use_chrome_profile)
    │     • self._temp_profile_dir = None    ← NEW: track temp dir
    │     • self._persistent_dir = ...       ← NEW: ~/.co/browser_profile/
    │     • (no browser launch — stays lazy)
    │
    ├── open_browser()                        ← MODIFY
    │     • _create_temp_profile()            ← NEW helper
    │     • _copy_persistent_profile()        ← NEW helper
    │     • launch_persistent_context(TEMP)   ← Use temp dir, not shared
    │     • Retry on SingletonLock (3x)       ← NEW
    │
    ├── _create_temp_profile()                ← NEW
    │     • tempfile.mkdtemp(prefix='co-browser-')
    │     • Store in self._temp_profile_dir
    │
    ├── _copy_persistent_profile()            ← NEW
    │     • If ~/.co/browser_profile/Default exists:
    │       shutil.copytree → temp_dir/Default
    │     • Copy Local State file if exists
    │
    ├── _save_back_to_persistent()            ← NEW
    │     • Copy temp_dir/Default → persistent/Default
    │     • Copy Local State back
    │     • Only if persistent profile dir was used
    │
    ├── close()                               ← MODIFY
    │     • _save_back_to_persistent()
    │     • Close browser/playwright
    │     • shutil.rmtree(self._temp_profile_dir)
    │
    └── [all other methods unchanged]

🔄 Data Flow

User calls go_to("x.com")
     │
     ▼ open_browser() (lazy, first call only)
     │
     ├─── ~/.co/browser_profile/ exists?
     │         │
     │    YES  │  NO
     │    ↓    │  ↓
     │  Copy   │  Empty temp dir
     │  to tmp │
     │    ↓    ↓
     │
     ▼ temp = /tmp/co-browser-{uuid}/
     │
     ▼ launch_persistent_context(temp, headless, args...)
     │
     │    ❌ SingletonLock error?
     │    ↓
     │    New temp dir → retry (max 3)
     │
     ▼ Browser ready
     │
     ▼ go_to("x.com") → navigate → _save_context()
     │
     ... (agent uses browser normally)
     │
     ▼ close()
     │
     ├─ Copy temp/Default → ~/.co/browser_profile/Default
     ├─ Close playwright
     └─ rmtree(temp)

📝 Implementation Steps

1. Add temp profile creation in open_browser()

   • File: browser.py:82-146
   • Replace direct use of ~/.co/browser_profile/ with temp dir creation
   • Add _create_temp_profile() method using tempfile.mkdtemp(prefix='co-browser-')
   • Store path in self._temp_profile_dir

2. Add profile copy logic

   • Add _copy_persistent_profile() method
   • Copies Default/ subdirectory (Chromium profile data) via shutil.copytree
   • Copies Local State file (encryption keys for cookies)
   • Skip if persistent dir doesn't exist or is empty (first run)
   • Only copy for Chrome (not Chromium) to match browser-use behavior

3. Add SingletonLock retry in open_browser()

   • Wrap launch_persistent_context() in retry loop (max 3 attempts)
   • On lock error: create new temp dir, retry
   • Track temp dirs for cleanup

4. Add save-back-to-persistent in close()

   • Add _save_back_to_persistent() method
   • Copy Default/ from temp back to ~/.co/browser_profile/
   • Copy Local State back
   • Then shutil.rmtree(self._temp_profile_dir) to cleanup

5. Update close() for cleanup

   • File: browser.py:492-506
   • Call _save_back_to_persistent() before closing
   • Delete temp dir after browser is closed
   • Handle __exit__ cleanup too

6. Update __init__ to track state

   • Add self._temp_profile_dir: str | None = None
   • Add self._persistent_dir = Path.home() / ".co" / "browser_profile"
   • Keep browser lazy (no change to existing lazy behavior)

⚠️ Risks & Considerations

• First-run experience: No persistent profile exists yet — temp dir will be fresh, user logs in, cookies save back to persistent on close. Next session copies those cookies. Works naturally.

• Crash without cleanup: If process crashes, temp dir in /tmp is orphaned. OS will clean /tmp eventually. Could add atexit handler as safety net, but /tmp cleanup is sufficient.

• Profile copy size: Chrome profiles can be large (100MB+). shutil.copytree is blocking but only runs once at browser open. For co ai this happens per-request which is fine since browser sessions are long-lived.

• Concurrent sessions: Two simultaneous sessions each get their own temp dir — no conflict. But both saving back to persistent dir could race. Last-write-wins is acceptable here (rare scenario, and cookies/localStorage are additive).

• sync_playwright() in async: This fix addresses the SingletonLock issue. The sync-in-async issue (sync_playwright() inside asyncio loop) is separate — it happens because agent.input() is already run via asyncio.to_thread() in the host server (see server.py:267), which should work. If it doesn't, that's a separate issue to investigate (Playwright detecting the outer loop).

🧪 Testing Strategy

• Unit test: Mock shutil.copytree, tempfile.mkdtemp, verify profile is created in temp dir
• Unit test: Verify close() calls rmtree on temp dir
• Unit test: Verify SingletonLock retry creates new temp dir
• Integration test: Launch browser, navigate, close, verify persistent profile has cookies
• Manual test in co ai: Start server, send two sequential browser requests, verify second doesn't get SingletonLock error
• Edge case: Test with no existing persistent profile (first run)
• Edge case: Test cleanup when close() is called but browser never opened (lazy init)

[wu-changxing]

pls do research about how browser use work, like json and tmp profile folder how it works how to apply to our situation

[wu-changxing]

🔍 Summary

BrowserAutomation.open_browser() launches with launch_persistent_context() pointing directly at ~/.co/browser_profile/. This shared profile causes SingletonLock conflicts across sequential server sessions and blocks new launches. Fix by adopting browser-use's temp-copy pattern: create a temp dir per session, copy the persistent profile into it, launch against the temp dir, and clean up on close.

📊 Current vs Proposed

CURRENT (Broken — shared profile locks):

  Session 1                          Session 2
  ────────                          ────────
  open_browser()                    open_browser()
       │                                 │
       ▼                                 ▼
  ┌──────────────────────┐         ┌──────────────────────┐
  │ sync_playwright()    │         │ sync_playwright()    │
  │ launch_persistent(   │         │ launch_persistent(   │
  │   ~/.co/browser_     │         │   ~/.co/browser_     │
  │   profile/)          │         │   profile/)          │
  └──────────┬───────────┘         └──────────┬───────────┘
             │                                │
             ▼                                ▼
  ┌──────────────────────┐         ┌──────────────────────┐
  │ ~/.co/browser_profile│         │ ~/.co/browser_profile│
  │ ├── Default/         │◄────────│ ❌ SingletonLock!!   │
  │ └── SingletonLock 🔒 │  SAME   │    "Failed to create │
  └──────────────────────┘  DIR    │     ProcessSingleton"│
                                   └──────────────────────┘

  Session 1 never closed → SingletonLock persists → Session 2 blocked


PROPOSED (Isolated — temp copy per session):

  Session 1                          Session 2
  ────────                          ────────
  open_browser()                    open_browser()
       │                                 │
       ├─ mkdtemp("co-browser-")         ├─ mkdtemp("co-browser-")
       ├─ copytree(persistent→temp)      ├─ copytree(persistent→temp)
       │                                 │
       ▼                                 ▼
  ┌──────────────────────┐         ┌──────────────────────┐
  │ launch_persistent(   │         │ launch_persistent(   │
  │   /tmp/co-browser-   │         │   /tmp/co-browser-   │
  │   a1b2c3/)           │         │   d4e5f6/)           │
  └──────────┬───────────┘         └──────────┬───────────┘
             │                                │
             ▼                                ▼
  ┌──────────────────────┐         ┌──────────────────────┐
  │ /tmp/co-browser-a1b2 │         │ /tmp/co-browser-d4e5 │
  │ ├── Default/         │         │ ├── Default/         │
  │ └── SingletonLock 🔒 │         │ └── SingletonLock 🔒 │
  └──────────────────────┘         └──────────────────────┘
       ISOLATED ✅                      ISOLATED ✅
       │                                │
  close()                          close()
       │                                │
       ├─ save cookies back             ├─ save cookies back
       │  to ~/.co/browser_profile/     │  to ~/.co/browser_profile/
       └─ rmtree(temp) ✅              └─ rmtree(temp) ✅

🔄 Browser Lifecycle (New)

BrowserAutomation.__init__(headless, use_chrome_profile)
     │
     │  self._temp_profile_dir = None   ← NEW state
     │  self._persistent_dir = ~/.co/browser_profile/
     │  (no browser launched — stays lazy)
     ▼
open_browser()  ← called on first go_to() or explicitly
     │
     ├─ 1. Create temp dir
     │     tempfile.mkdtemp(prefix="co-browser-")
     │     → /tmp/co-browser-a1b2c3/
     │
     ├─ 2. Copy persistent profile?
     │     │
     │     ├── ~/.co/browser_profile/Default/ exists?
     │     │      YES → shutil.copytree → temp/Default/
     │     │             copy Local State → temp/Local State
     │     │      NO  → fresh temp dir (first run ever)
     │     │
     │     └── Remove any stale SingletonLock from the copy
     │
     ├─ 3. launch_persistent_context(TEMP_DIR, ...)
     │     ✅ Each session isolated — no lock conflict
     │
     ▼
  [Browser session active — tools work normally]
     │
close()
     │
     ├─ 4. _save_context()                    (500ms wait)
     ├─ 5. Copy Default/ BACK to persistent   (preserve login state)
     ├─ 6. page.close() → browser.close() → playwright.stop()
     └─ 7. shutil.rmtree(temp_dir)            (cleanup)

📁 Files to Change

connectonion/useful_tools/browser_tools/
├── browser.py          ← MODIFY (only this file changes)
│   ├── __init__()      ← Add _temp_profile_dir, _persistent_dir
│   ├── open_browser()  ← Temp profile creation + copy + launch
│   ├── close()         ← Save-back + cleanup temp dir
│   ├── _create_temp_profile()    ← NEW helper
│   └── _save_back_to_persistent()← NEW helper
├── browser_config.py   ← NO CHANGE
├── element_finder.py   ← NO CHANGE
├── scroll.py           ← NO CHANGE
└── __init__.py         ← NO CHANGE

tests/
└── unit/
    └── test_browser_profile.py   ← NEW (unit tests for profile isolation)

🏗️ Architecture: What Changes in browser.py

class BrowserAutomation:
    │
    ├── __init__(headless, use_chrome_profile)
    │     existing: playwright, browser, page, current_url, form_data, ...
    │     + self._temp_profile_dir: str | None = None     ← NEW
    │     + self._persistent_dir = ~/.co/browser_profile/  ← NEW (extracted)
    │
    ├── open_browser()                              ← MODIFY
    │     BEFORE: launch_persistent_context(~/.co/browser_profile/)
    │     AFTER:  _create_temp_profile()
    │             launch_persistent_context(self._temp_profile_dir)
    │
    ├── _create_temp_profile() → str                ← NEW
    │     1. tempfile.mkdtemp(prefix="co-browser-")
    │     2. If persistent Default/ exists:
    │        shutil.copytree(persistent/Default, temp/Default)
    │        shutil.copy(persistent/Local State, temp/Local State)
    │     3. Remove SingletonLock from copy (stale lock safety)
    │     4. Return temp dir path
    │
    ├── _save_back_to_persistent()                  ← NEW
    │     1. If temp/Default exists and persistent dir configured:
    │        Remove old persistent/Default
    │        shutil.copytree(temp/Default, persistent/Default)
    │        Copy Local State back
    │     2. Only runs if use_chrome_profile=True
    │
    ├── close()                                     ← MODIFY
    │     1. _save_context()
    │     + _save_back_to_persistent()              ← ADD
    │     2. page.close() → browser.close() → playwright.stop()
    │     + shutil.rmtree(self._temp_profile_dir)   ← ADD
    │     + self._temp_profile_dir = None
    │
    ├── __exit__()                                  ← NO CHANGE (calls close)
    │
    └── [all other methods unchanged]

🔄 Data Flow: Profile Copy

LAUNCH (open_browser):

  ~/.co/browser_profile/          /tmp/co-browser-a1b2c3/
  ├── Default/            ──copy──▶ ├── Default/
  │   ├── Cookies                   │   ├── Cookies
  │   ├── Local Storage/            │   ├── Local Storage/
  │   └── ...                       │   └── ...
  ├── Local State         ──copy──▶ ├── Local State
  └── SingletonLock       ──skip──▶ (not copied / deleted if present)

  launch_persistent_context("/tmp/co-browser-a1b2c3/")
  → Chromium creates its own SingletonLock in temp dir ✅


CLOSE (close):

  /tmp/co-browser-a1b2c3/          ~/.co/browser_profile/
  ├── Default/            ──copy──▶ ├── Default/    (updated cookies!)
  │   ├── Cookies (updated)         │   ├── Cookies
  │   └── ...                       │   └── ...
  ├── Local State         ──copy──▶ ├── Local State
  └── SingletonLock       ──skip──▶ (not copied back)

  shutil.rmtree("/tmp/co-browser-a1b2c3/")  ← clean ✅

📝 Implementation Steps

1. Add temp profile state to __init__() — browser.py:64-80

   • Add self._temp_profile_dir: str | None = None
   • Extract self._persistent_dir = Path.home() / ".co" / "browser_profile" (already there as local var, promote to instance)

2. Add _create_temp_profile() method — new method

   • tempfile.mkdtemp(prefix="co-browser-")
   • If self._persistent_dir / "Default" exists → shutil.copytree to temp
   • Copy Local State file if exists
   • Remove SingletonLock from the copy (safety)
   • Store in self._temp_profile_dir

3. Modify open_browser() to use temp profile — browser.py:82-146

   • Call self._create_temp_profile() before launch
   • Replace str(profile_dir) with self._temp_profile_dir in launch_persistent_context()
   • Remove the profile_dir.mkdir() call (persistent dir creation moves to save-back)

4. Add _save_back_to_persistent() method — new method

   • Only if self.use_chrome_profile and self._temp_profile_dir
   • Copy temp/Default/ → persistent/Default/ (replace existing)
   • Copy Local State back
   • Skip SingletonLock when copying back

5. Modify close() to cleanup temp dir — browser.py:492-506

   • Call self._save_back_to_persistent() after _save_context() but before closing browser
   • After closing browser+playwright: shutil.rmtree(self._temp_profile_dir, ignore_errors=True)
   • Reset self._temp_profile_dir = None

6. Add __del__ safety net — new method

   • If self._temp_profile_dir still exists (close was never called), clean it up
   • shutil.rmtree(self._temp_profile_dir, ignore_errors=True)
   • This handles the server mode case where agents are garbage collected

⚠️ Risks & Considerations

• Race condition on save-back: If two sessions close simultaneously, the last one to copy back wins. This is acceptable — same behavior as any shared resource, and unlikely in practice since sessions are sequential per user.
• Disk space: Each temp profile copy could be ~50-200MB for a mature Chrome profile. rmtree in close() handles this. __del__ is the safety net.
• First run: No persistent profile exists yet → fresh temp dir works fine. First close() creates the persistent dir.
• use_chrome_profile=False case: Skip all copy logic, just use a fresh temp dir with no copy. Same isolation benefit.
• Performance: copytree of a Chrome profile adds 1-3 seconds to browser startup. Acceptable tradeoff for reliability.

🧪 Testing Strategy

1. Unit test: temp profile creation — mock tempfile.mkdtemp, verify _create_temp_profile() creates correct structure
2. Unit test: SingletonLock removal — create a fake profile with SingletonLock, verify it's removed from the copy
3. Unit test: save-back logic — verify _save_back_to_persistent() copies Default/ and Local State, skips SingletonLock
4. Unit test: cleanup on close — verify temp dir is removed after close()
5. Unit test: __del__ safety — verify temp dir cleaned up on garbage collection
6. Integration test: sequential sessions — open browser, close, open again → no SingletonLock error
7. Manual test in co ai server mode — start server, run browser tool, end session, run browser tool again → works