browser-automation-cli 0.1.0__py2.py3-none-any.whl

browser_automation_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: browser-automation-cli
+Version: 0.1.0
+Summary: Browser automation daemon + CLI for coding agents. Persistent sessions, no MCP, no extensions.
+Project-URL: Homepage, https://github.com/jshan9078/browser-automation-cli
+Project-URL: Repository, https://github.com/jshan9078/browser-automation-cli
+License-File: LICENSE.txt

browser_automation_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+cli/main.py,sha256=eQA5jji9rSQmygQt6Wn4L-Ys71bKTwEM5MeFgOjElQk,12342
+daemon/browser.py,sha256=9f_ZEIXrGEkRaO9ln_TR0NKoA9_KD3sE47-GnEbvqtU,8972
+daemon/server.py,sha256=lsL9gNuaiaowbDGEjstDqzf9VOqXujgB3-vcVZNjikI,4357
+daemon/session.py,sha256=GxGFBKTehRBHLGguwDrbA_XGwLJgHOphXKGRJOtkIhs,2947
+browser_automation_cli-0.1.0.dist-info/METADATA,sha256=O1gB3KBcj9jdBsi09R_Ex0aYI3hLumYHS1l88LgOefM,348
+browser_automation_cli-0.1.0.dist-info/WHEEL,sha256=e22IIVjxDyt0lABi4WpktFIGsmO_ebSDXLnPUbPK0E0,105
+browser_automation_cli-0.1.0.dist-info/entry_points.txt,sha256=ev7XKNYCN3ODry1OPBmN0ZgAHxsm8QcYjdZkA2lZteY,78
+browser_automation_cli-0.1.0.dist-info/licenses/LICENSE.txt,sha256=jWVqb-E4JWCYCS7z3ykzrLmzBRE68zOLJyvKbZpo-mU,1080
+browser_automation_cli-0.1.0.dist-info/RECORD,,

browser_automation_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

browser_automation_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+browser = cli.main:main
+browser-daemon = daemon.server:main

browser_automation_cli-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Browser CLI Maintainers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cli/main.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+import asyncio
+import base64
+import json
+import logging
+import subprocess
+import sys
+from pathlib import Path
+
+SOCKET_PATH = Path.home() / ".browser-daemon" / "socket"
+
+
+async def cmd_capture(url: str, full_page: bool = True, output: str | None = None):
+    """Standalone screenshot capture without daemon. Saves to /tmp."""
+    from playwright.async_api import async_playwright
+    import time
+    
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+        
+        # Create context with anti-detection measures
+        context = await browser.new_context(
+            viewport={"width": 1920, "height": 1080},
+            user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"
+        )
+        
+        # Hide navigator.webdriver to avoid automation detection
+        await context.add_init_script("""
+            Object.defineProperty(navigator, 'webdriver', {
+                get: () => undefined,
+                configurable: true
+            });
+        """)
+        
+        page = await context.new_page()
+        
+        try:
+            await page.goto(url, wait_until="networkidle", timeout=30000)
+            
+            # Wait for body to be fully loaded/rendered
+            await page.wait_for_selector("body", state="attached")
+            await page.wait_for_load_state("domcontentloaded")
+            await asyncio.sleep(2)  # Additional wait for JS frameworks
+            
+            # Take screenshot - JPEG for smaller file size
+            screenshot_bytes = await page.screenshot(
+                full_page=full_page,
+                type="jpeg",
+                quality=85
+            )
+            
+            # Determine output path
+            timestamp = int(time.time())
+            if output:
+                output_path = Path(output)
+            else:
+                filename = f"browser_capture_{timestamp}.jpg"
+                output_path = Path("/tmp") / filename
+            
+            output_path.write_bytes(screenshot_bytes)
+            
+            print(json.dumps({
+                "success": True, 
+                "path": str(output_path),
+                "full_page": full_page,
+                "format": "jpeg"
+            }))
+                
+        except Exception as e:
+            print(json.dumps({"success": False, "error": str(e)}), file=sys.stderr)
+            sys.exit(1)
+        finally:
+            await context.close()
+            await browser.close()
+
+
+async def send_request(request: dict) -> dict:
+    try:
+        reader, writer = await asyncio.open_unix_connection(str(SOCKET_PATH))
+        writer.write(json.dumps(request).encode())
+        await writer.drain()
+        writer.write_eof()  # Signal we're done writing
+        
+        # Read all data until connection is closed
+        chunks = []
+        while True:
+            chunk = await reader.read(65536)
+            if not chunk:
+                break
+            chunks.append(chunk)
+        
+        data = b''.join(chunks)
+        writer.close()
+        await writer.wait_closed()
+        return json.loads(data.decode())
+    except FileNotFoundError:
+        return {"success": False, "error": "Daemon not running. Start with: browser-daemon"}
+    except ConnectionRefusedError:
+        return {"success": False, "error": "Connection refused. Is another daemon running?"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def cmd_create():
+    result = await send_request({"action": "create"})
+    if result["success"]:
+        print(result["session_id"])
+    else:
+        print(f"Error: {result.get('error')}", file=sys.stderr)
+        sys.exit(1)
+
+
+async def cmd_list():
+    result = await send_request({"action": "list"})
+    if not result["success"]:
+        print(f"Error: {result.get('error')}", file=sys.stderr)
+        sys.exit(1)
+
+    sessions = result.get("sessions", [])
+    if not sessions:
+        print("No active sessions")
+        return
+
+    print(f"{'SESSION_ID':<12} {'URL':<50} {'TITLE'}")
+    print("-" * 100)
+    for s in sessions:
+        url = s["url"][:48] if s["url"] else "(empty)"
+        title = s["title"][:30] if s["title"] else ""
+        print(f"{s['session_id']:<12} {url:<50} {title}")
+
+
+async def cmd_delete(session_id: str):
+    result = await send_request({"action": "delete", "session_id": session_id})
+    if result["success"]:
+        print(f"Deleted session {session_id}")
+    else:
+        print(f"Error: {result.get('error')}", file=sys.stderr)
+        sys.exit(1)
+
+
+async def cmd_navigate(session_id: str, url: str):
+    result = await send_request({"action": "navigate", "session_id": session_id, "params": {"url": url}})
+    print_json(result)
+
+
+async def cmd_snapshot(session_id: str, selector: str | None):
+    params = {"selector": selector} if selector else {}
+    result = await send_request({"action": "snapshot", "session_id": session_id, "params": params})
+    print_json(result)
+
+
+async def cmd_click(session_id: str, selector: str):
+    result = await send_request({"action": "click", "session_id": session_id, "params": {"selector": selector}})
+    print_json(result)
+
+
+async def cmd_type(session_id: str, selector: str, text: str):
+    result = await send_request({"action": "type", "session_id": session_id, "params": {"selector": selector, "text": text}})
+    print_json(result)
+
+
+async def cmd_hover(session_id: str, selector: str):
+    result = await send_request({"action": "hover", "session_id": session_id, "params": {"selector": selector}})
+    print_json(result)
+
+
+async def cmd_select_option(session_id: str, selector: str, value: str):
+    result = await send_request({"action": "select_option", "session_id": session_id, "params": {"selector": selector, "value": value}})
+    print_json(result)
+
+
+async def cmd_press_key(session_id: str, key: str):
+    result = await send_request({"action": "press_key", "session_id": session_id, "params": {"key": key}})
+    print_json(result)
+
+
+async def cmd_screenshot(session_id: str, selector: str | None, output: str | None = None):
+    params = {}
+    if selector:
+        params["selector"] = selector
+    if output:
+        params["output"] = output
+    result = await send_request({"action": "screenshot", "session_id": session_id, "params": params})
+    print_json(result)
+
+
+async def cmd_go_back(session_id: str):
+    result = await send_request({"action": "go_back", "session_id": session_id})
+    print_json(result)
+
+
+async def cmd_go_forward(session_id: str):
+    result = await send_request({"action": "go_forward", "session_id": session_id})
+    print_json(result)
+
+
+def cmd_install():
+    try:
+        subprocess.run([sys.executable, "-m", "playwright", "install", "chromium"], check=True)
+        print("Installed Chromium for Browser CLI")
+    except subprocess.CalledProcessError as e:
+        print(f"Error: failed to install Chromium ({e.returncode})", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_cleanup():
+    """Kill all Playwright Chrome processes."""
+    try:
+        result = subprocess.run(
+            ["pkill", "-f", "playwright"],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            print("Killed Playwright Chrome processes")
+        elif result.returncode == 1:
+            print("No Playwright processes found")
+        else:
+            print(f"Error: pkill returned {result.returncode}", file=sys.stderr)
+            sys.exit(1)
+    except FileNotFoundError:
+        print("Error: pkill not found", file=sys.stderr)
+        sys.exit(1)
+
+
+def print_json(data: dict):
+    print(json.dumps(data, indent=2))
+
+
+def main():
+    logging.basicConfig(level=logging.WARNING)
+
+    args = sys.argv[1:]
+
+    if len(args) == 0 or args[0] in ("-h", "--help"):
+        print("""Browser CLI - Authenticated browser automation
+
+Standalone Commands (no daemon required):
+  browser capture <url> [options]       Capture screenshot to /tmp
+    Options:
+      -f, --full-page                   Capture full page (default: viewport only)
+      -o, --output <path>               Custom output path
+
+    Examples:
+      browser capture https://example.com
+      browser capture https://example.com -f
+      browser capture https://example.com -o ./screenshot.jpg
+
+Daemon Commands (requires browser-daemon running):
+  browser install                       Install Chromium runtime
+  browser cleanup                       Kill stale Chrome processes
+  browser create                        Create new session (opens browser for login)
+  browser list                          List active sessions
+  browser <id> navigate <url>          Navigate to URL
+  browser <id> snapshot [selector]      Get page elements
+  browser <id> click <selector>         Click element
+  browser <id> type <selector> <text>   Type text
+  browser <id> hover <selector>         Hover element
+  browser <id> select <selector> <val>  Select dropdown option
+  browser <id> press <key>              Press keyboard key
+  browser <id> screenshot [selector] [-o <path>]
+                                        Take screenshot (JPEG, saved to /tmp)
+                                        Use -o for custom output path
+  browser <id> back                      Go back
+  browser <id> forward                   Go forward
+  browser <id> delete                    Delete session
+  browser -h, --help                    Show this help
+
+Start daemon: browser-daemon
+""")
+        return
+
+    asyncio.run(_main(args))
+
+
+async def _main(args: list[str]):
+    cmd = args[0]
+
+    if cmd == "capture" and len(args) >= 2:
+        url = args[1]
+        full_page = True  # Default to full page for better results
+        output = None
+        
+        # Parse flags
+        i = 2
+        while i < len(args):
+            if args[i] in ("-f", "--full-page"):
+                full_page = True
+                i += 1
+            elif args[i] in ("-o", "--output") and i + 1 < len(args):
+                output = args[i + 1]
+                i += 2
+            else:
+                i += 1
+        
+        await cmd_capture(url, full_page=full_page, output=output)
+    elif cmd == "install":
+        cmd_install()
+    elif cmd == "cleanup":
+        cmd_cleanup()
+    elif cmd == "create":
+        await cmd_create()
+    elif cmd == "list":
+        await cmd_list()
+    elif cmd == "delete" and len(args) >= 2:
+        await cmd_delete(args[1])
+    elif len(args) >= 2:
+        session_id = args[0]
+        action = args[1]
+
+        if action == "navigate" and len(args) >= 3:
+            await cmd_navigate(session_id, args[2])
+        elif action == "snapshot":
+            selector = args[2] if len(args) >= 3 else None
+            await cmd_snapshot(session_id, selector)
+        elif action == "click" and len(args) >= 3:
+            await cmd_click(session_id, args[2])
+        elif action == "type" and len(args) >= 4:
+            await cmd_type(session_id, args[2], args[3])
+        elif action == "hover" and len(args) >= 3:
+            await cmd_hover(session_id, args[2])
+        elif action == "select" and len(args) >= 4:
+            await cmd_select_option(session_id, args[2], args[3])
+        elif action == "press" and len(args) >= 3:
+            await cmd_press_key(session_id, args[2])
+        elif action == "screenshot":
+            selector = None
+            output = None
+            i = 2
+            while i < len(args):
+                if args[i] in ("-o", "--output") and i + 1 < len(args):
+                    output = args[i + 1]
+                    i += 2
+                elif args[i] and not args[i].startswith("-"):
+                    selector = args[i]
+                    i += 1
+                else:
+                    i += 1
+            await cmd_screenshot(session_id, selector, output)
+        elif action == "back":
+            await cmd_go_back(session_id)
+        elif action == "forward":
+            await cmd_go_forward(session_id)
+        elif action == "delete":
+            await cmd_delete(session_id)
+        else:
+            print(f"Unknown action or missing args: {action}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        print("Invalid command", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

daemon/browser.py

@@ -0,0 +1,236 @@
+import base64
+import logging
+from typing import Any
+
+from playwright.async_api import Page
+
+logger = logging.getLogger(__name__)
+
+
+async def navigate(page: Page, url: str) -> dict[str, Any]:
+    logger.debug(f"Navigating to {url}")
+    try:
+        await page.goto(url, wait_until="domcontentloaded", timeout=30000)
+        await page.wait_for_load_state("networkidle", timeout=10000)
+        return {
+            "success": True,
+            "url": page.url,
+            "title": await page.title(),
+        }
+    except Exception as e:
+        logger.error(f"Navigation failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def snapshot(page: Page, selector: str | None = None) -> dict[str, Any]:
+    logger.debug(f"Taking snapshot (selector={selector})")
+    try:
+        # Use page.evaluate to get element data and page state
+        result = await page.evaluate("""(selector) => {
+            function getSelector(el) {
+                // Try to build a good CSS selector
+                if (el.id) return '#' + el.id;
+                if (el.name && ['input', 'select', 'textarea', 'button'].includes(el.tagName.toLowerCase())) {
+                    return el.tagName.toLowerCase() + '[name="' + el.name + '"]';
+                }
+                if (el.getAttribute('data-testid')) return '[data-testid="' + el.getAttribute('data-testid') + '"]';
+                
+                // Build class selector
+                const classes = Array.from(el.classList).filter(c => !c.match(/^[0-9]/)).slice(0, 2);
+                if (classes.length > 0) {
+                    return el.tagName.toLowerCase() + '.' + classes.join('.');
+                }
+                
+                // Text-based selector for clickable elements
+                const text = el.innerText?.trim();
+                if (text && text.length < 50 && ['a', 'button'].includes(el.tagName.toLowerCase())) {
+                    return el.tagName.toLowerCase() + ':has-text("' + text.replace(/"/g, '\\"') + '")';
+                }
+                
+                // nth-child fallback
+                const parent = el.parentElement;
+                if (parent) {
+                    const siblings = Array.from(parent.children).filter(c => c.tagName === el.tagName);
+                    if (siblings.length > 1) {
+                        const index = siblings.indexOf(el) + 1;
+                        return getSelector(parent) + ' > ' + el.tagName.toLowerCase() + ':nth-child(' + index + ')';
+                    }
+                    return getSelector(parent) + ' > ' + el.tagName.toLowerCase();
+                }
+                return el.tagName.toLowerCase();
+            }
+            
+            const elements = selector 
+                ? Array.from(document.querySelectorAll(selector))
+                : Array.from(document.body.querySelectorAll('*'));
+            
+            const elementData = elements.slice(0, 100).map((el, i) => {
+                const tag = el.tagName.toLowerCase();
+                if (['script', 'style', 'meta', 'link', 'noscript'].includes(tag)) return null;
+                
+                const text = (el.innerText || '').replace(/\\s+/g, ' ').trim().slice(0, 150);
+                const isInteractive = ['a', 'button', 'input', 'select', 'textarea'].includes(tag) || 
+                                      el.onclick || el.getAttribute('role') === 'button';
+                
+                return {
+                    ref: 'el_' + i,
+                    tag: tag,
+                    selector: getSelector(el),
+                    text: text || null,
+                    interactive: isInteractive,
+                    href: el.href || null,
+                    name: el.name || null,
+                    placeholder: el.placeholder || null,
+                    ariaLabel: el.getAttribute('aria-label') || null,
+                };
+            }).filter(Boolean);
+            
+            return {
+                elements: elementData,
+                scrollY: window.scrollY,
+                viewportHeight: window.innerHeight,
+                documentHeight: document.documentElement.scrollHeight
+            };
+        }""", selector)
+
+        return {
+            "success": True, 
+            "url": page.url,
+            "title": await page.title(),
+            "scrollY": result["scrollY"],
+            "viewportHeight": result["viewportHeight"],
+            "documentHeight": result["documentHeight"],
+            "elements": result["elements"]
+        }
+    except Exception as e:
+        logger.error(f"Snapshot failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def click(page: Page, selector: str) -> dict[str, Any]:
+    logger.debug(f"Clicking {selector}")
+    try:
+        await page.click(selector, timeout=10000)
+        await page.wait_for_load_state("domcontentloaded", timeout=10000)
+        return {"success": True, "url": page.url, "title": await page.title()}
+    except Exception as e:
+        logger.error(f"Click failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def type_text(page: Page, selector: str, text: str) -> dict[str, Any]:
+    logger.debug(f"Typing into {selector}")
+    try:
+        await page.fill(selector, text, timeout=10000)
+        return {"success": True}
+    except Exception as e:
+        logger.error(f"Type failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def hover(page: Page, selector: str) -> dict[str, Any]:
+    logger.debug(f"Hovering {selector}")
+    try:
+        await page.hover(selector, timeout=10000)
+        return {"success": True}
+    except Exception as e:
+        logger.error(f"Hover failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def select_option(page: Page, selector: str, value: str) -> dict[str, Any]:
+    logger.debug(f"Selecting {value} in {selector}")
+    try:
+        await page.select_option(selector, value, timeout=10000)
+        return {"success": True}
+    except Exception as e:
+        logger.error(f"Select failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def press_key(page: Page, key: str) -> dict[str, Any]:
+    logger.debug(f"Pressing key {key}")
+    try:
+        await page.keyboard.press(key)
+        return {"success": True}
+    except Exception as e:
+        logger.error(f"Press failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def screenshot(page: Page, selector: str | None = None, output: str | None = None) -> dict[str, Any]:
+    logger.debug(f"Taking screenshot (selector={selector})")
+    try:
+        from pathlib import Path
+        import time
+        
+        if selector:
+            element = await page.query_selector(selector)
+            if element:
+                image_bytes = await element.screenshot(type="jpeg", quality=85)
+            else:
+                return {"success": False, "error": f"Element not found: {selector}"}
+        else:
+            image_bytes = await page.screenshot(type="jpeg", quality=85)
+
+        # Save to file
+        if output:
+            output_path = Path(output)
+        else:
+            timestamp = int(time.time())
+            filename = f"browser_screenshot_{timestamp}.jpg"
+            output_path = Path("/tmp") / filename
+        
+        output_path.write_bytes(image_bytes)
+        
+        return {"success": True, "path": str(output_path), "format": "jpeg"}
+    except Exception as e:
+        logger.error(f"Screenshot failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def console_logs(page: Page) -> dict[str, Any]:
+    logger.debug("Getting console logs")
+    try:
+        logs = await page.evaluate("""() => {
+            return window.__browser_logs || [];
+        }""")
+        return {"success": True, "logs": logs}
+    except Exception as e:
+        logger.error(f"Console logs failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def go_back(page: Page) -> dict[str, Any]:
+    logger.debug("Going back")
+    try:
+        await page.go_back(wait_until="domcontentloaded", timeout=15000)
+        return {"success": True, "url": page.url, "title": await page.title()}
+    except Exception as e:
+        logger.error(f"Go back failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+async def go_forward(page: Page) -> dict[str, Any]:
+    logger.debug("Going forward")
+    try:
+        await page.go_forward(wait_until="domcontentloaded", timeout=15000)
+        return {"success": True, "url": page.url, "title": await page.title()}
+    except Exception as e:
+        logger.error(f"Go forward failed: {e}")
+        return {"success": False, "error": str(e)}
+
+
+ACTIONS = {
+    "navigate": navigate,
+    "snapshot": snapshot,
+    "click": click,
+    "type": type_text,
+    "hover": hover,
+    "select_option": select_option,
+    "press_key": press_key,
+    "screenshot": screenshot,
+    "console_logs": console_logs,
+    "go_back": go_back,
+    "go_forward": go_forward,
+}

daemon/server.py

@@ -0,0 +1,152 @@
+import asyncio
+import json
+import logging
+import os
+import signal
+from pathlib import Path
+
+from playwright.async_api import async_playwright
+
+from .browser import ACTIONS
+from .session import SessionManager
+
+logger = logging.getLogger(__name__)
+
+SOCKET_PATH = Path.home() / ".browser-daemon" / "socket"
+
+
+class Daemon:
+    def __init__(self):
+        self.sessions = SessionManager()
+        self.browser = None
+        self.browser_launcher = None
+        self.server = None
+        self._shutdown = asyncio.Event()
+
+    async def start(self):
+        logger.info("Starting browser daemon...")
+
+        os.makedirs(SOCKET_PATH.parent, exist_ok=True)
+
+        if SOCKET_PATH.exists():
+            SOCKET_PATH.unlink()
+
+        self.browser_launcher = await async_playwright().start()
+        self.browser = await self.browser_launcher.chromium.launch(
+            headless=False,
+            args=[
+                "--disable-dev-shm-usage",
+                "--no-sandbox",
+                "--disable-blink-features=AutomationControlled",
+            ],
+        )
+        logger.info(f"Browser launched, socket at {SOCKET_PATH}")
+
+        self.server = await asyncio.start_unix_server(
+            self.handle_client,
+            path=str(SOCKET_PATH),
+        )
+
+        logger.info("Daemon ready")
+
+        await self._shutdown.wait()
+
+    async def handle_client(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
+        try:
+            data = await reader.read(10 * 1024 * 1024)  # 10MB max
+            if not data:
+                return
+
+            request = json.loads(data.decode())
+            logger.debug(f"Received: {request}")
+
+            response = await self.process(request)
+            writer.write(json.dumps(response).encode())
+            await writer.drain()
+            writer.close()
+            await writer.wait_closed()
+
+        except Exception as e:
+            logger.error(f"Client error: {e}")
+            try:
+                writer.write(json.dumps({"success": False, "error": str(e)}).encode())
+                await writer.drain()
+                writer.close()
+            except Exception:
+                pass
+
+    async def process(self, request: dict) -> dict:
+        action = request.get("action")
+        session_id = request.get("session_id")
+
+        if action == "create":
+            session = await self.sessions.create(self.browser)
+            return {"success": True, "session_id": session.id}
+
+        if action == "list":
+            sessions = await self.sessions.list()
+            return {"success": True, "sessions": sessions}
+
+        if action == "delete":
+            if not session_id:
+                return {"success": False, "error": "session_id required"}
+            deleted = await self.sessions.delete(session_id)
+            return {"success": deleted, "error": None if deleted else "Session not found"}
+
+        if not session_id:
+            return {"success": False, "error": "session_id required for this action"}
+
+        session = await self.sessions.get(session_id)
+        if not session:
+            return {"success": False, "error": f"Session {session_id} not found"}
+
+        if action not in ACTIONS:
+            return {"success": False, "error": f"Unknown action: {action}"}
+
+        handler = ACTIONS[action]
+        params = request.get("params", {})
+
+        return await handler(session.page, **params)
+
+    async def stop(self):
+        logger.info("Stopping daemon...")
+
+        if self.server:
+            self.server.close()
+            await self.server.wait_closed()
+
+        await self.sessions.close_all()
+
+        if self.browser:
+            await self.browser.close()
+
+        if self.browser_launcher:
+            await self.browser_launcher.stop()
+
+        if SOCKET_PATH.exists():
+            SOCKET_PATH.unlink()
+
+        self._shutdown.set()
+        logger.info("Daemon stopped")
+
+
+def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(message)s",
+    )
+
+    daemon = Daemon()
+    loop = asyncio.new_event_loop()
+
+    def signal_handler(sig, frame):
+        loop.create_task(daemon.stop())
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    loop.run_until_complete(daemon.start())
+
+
+if __name__ == "__main__":
+    main()

daemon/session.py

@@ -0,0 +1,91 @@
+import asyncio
+import logging
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+
+from playwright.async_api import Browser, BrowserContext, Page
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Session:
+    id: str
+    context: BrowserContext
+    page: Page
+    created_at: float = field(default_factory=time.time)
+
+    @property
+    def url(self) -> str:
+        return self.page.url
+
+
+class SessionManager:
+    def __init__(self):
+        self._sessions: dict[str, Session] = {}
+        self._lock = asyncio.Lock()
+        logger.info("SessionManager initialized")
+
+    async def create(self, browser: Browser) -> Session:
+        async with self._lock:
+            session_id = uuid.uuid4().hex[:8]
+            
+            # Set explicit desktop user agent
+            user_agent = (
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/123.0.0.0 Safari/537.36"
+            )
+            
+            context = await browser.new_context(
+                viewport={"width": 1920, "height": 1080},
+                user_agent=user_agent,
+            )
+            
+            # Hide navigator.webdriver to avoid automation detection
+            await context.add_init_script("""
+                Object.defineProperty(navigator, 'webdriver', {
+                    get: () => undefined,
+                    configurable: true
+                });
+            """)
+            
+            page = await context.new_page()
+            await page.set_viewport_size({"width": 1920, "height": 1080})
+            session = Session(id=session_id, context=context, page=page)
+            self._sessions[session_id] = session
+            logger.info(f"Created session {session_id}")
+            return session
+
+    async def get(self, session_id: str) -> Session | None:
+        async with self._lock:
+            return self._sessions.get(session_id)
+
+    async def list(self) -> list[dict[str, Any]]:
+        async with self._lock:
+            result = []
+            for s in self._sessions.values():
+                result.append({
+                    "session_id": s.id,
+                    "url": s.url,
+                    "title": await s.page.title(),
+                })
+            return result
+
+    async def delete(self, session_id: str) -> bool:
+        async with self._lock:
+            if session_id in self._sessions:
+                session = self._sessions.pop(session_id)
+                await session.context.close()
+                logger.info(f"Deleted session {session_id}")
+                return True
+            return False
+
+    async def close_all(self):
+        async with self._lock:
+            logger.info(f"Closing {len(self._sessions)} sessions")
+            for session in self._sessions.values():
+                await session.context.close()
+            self._sessions.clear()