Feat/eigent new design

.github/workflows/test.yml

@@ -67,6 +67,9 @@ jobs:
       - name: Check Electron Access Guard
         run: bash scripts/check-electron-access.sh
 
+      - name: Design tokens (engine + no hard-coded colors in UI)
+        run: npm run check:design-tokens
+
   pytest:
     name: Run Python Tests
     runs-on: ubuntu-latest

.gitignore

@@ -10,6 +10,7 @@ node-compile-cache
 
 node_modules
 dist
+dist-web
 !package/**/dist
 dist-ssr
 dist-electron

.lintstagedrc.json

@@ -1,6 +1,7 @@
 {
   "*.{ts,tsx}": [
     "eslint --fix --no-warn-ignored",
+    "node scripts/check-design-token-usage.mjs",
     "prettier --write",
     "node licenses/update_license.js"
   ],

backend/app/__init__.py

@@ -52,7 +52,7 @@ async def dispatch(self, request, call_next):
         response = await call_next(request)
         response.headers["X-Content-Type-Options"] = "nosniff"
         response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
-        if request.url.path.startswith("/files/preview/"):
+        if "/files/preview/" in request.url.path:
             if "X-Frame-Options" in response.headers:
                 del response.headers["X-Frame-Options"]
             response.headers["Content-Security-Policy"] = (

backend/app/controller/chat_controller.py

@@ -55,8 +55,9 @@
     task_locks,
 )
 from app.utils.browser_launcher import (
-    ensure_cdp_browser_available,
+    ensure_cdp_browser_endpoint,
     is_cdp_url_available,
+    normalize_cdp_url,
 )
 
 router = APIRouter()
@@ -109,7 +110,7 @@ async def _prepare_browser_for_request(
         return True
 
     try:
-        launched = await asyncio.to_thread(ensure_cdp_browser_available, port)
+        endpoint = await asyncio.to_thread(ensure_cdp_browser_endpoint, port)
     except Exception as e:
         os.environ.pop("EIGENT_CDP_URL", None)
         chat_logger.warning(
@@ -120,8 +121,10 @@ async def _prepare_browser_for_request(
             request.state.browser_available = False
         return False
 
-    if launched:
-        os.environ["EIGENT_CDP_URL"] = f"http://127.0.0.1:{port}"
+    if endpoint:
+        os.environ["EIGENT_CDP_URL"] = endpoint
+        _, _, selected_port = normalize_cdp_url(endpoint)
+        os.environ["browser_port"] = str(selected_port)
         if request is not None:
             request.state.browser_available = True
         return True

backend/app/controller/tool_controller.py

@@ -30,7 +30,7 @@
     DEFAULT_CDP_PORT,
     _is_cdp_available,
     _is_port_in_use,
-    ensure_cdp_browser_available,
+    ensure_cdp_browser_endpoint,
     is_local_cdp_host,
     normalize_cdp_url,
 )
@@ -50,6 +50,7 @@ class LinkedInTokenRequest(BaseModel):
 logger = logging.getLogger("tool_controller")
 router = APIRouter()
 _web_cdp_browser_meta: dict | None = None
+DEFAULT_LOGIN_BROWSER_CDP_PORT = 9323
 
 
 class CdpBrowserConnectRequest(BaseModel):
@@ -114,6 +115,37 @@ def _get_connected_cdp_port() -> int | None:
         return None
 
 
+def _get_login_browser_cdp_port() -> int:
+    """Dedicated CDP port for the user-login cookie browser.
+
+    Keep this outside the Browser Agent fallback range (9223-9299), otherwise
+    Cookie Management can mistake a managed task browser for the login window.
+    """
+    raw_port = os.environ.get("EIGENT_LOGIN_BROWSER_CDP_PORT")
+    if not raw_port:
+        return DEFAULT_LOGIN_BROWSER_CDP_PORT
+
+    try:
+        port = int(raw_port)
+    except ValueError:
+        logger.warning(
+            "Invalid EIGENT_LOGIN_BROWSER_CDP_PORT=%s; using default %s",
+            raw_port,
+            DEFAULT_LOGIN_BROWSER_CDP_PORT,
+        )
+        return DEFAULT_LOGIN_BROWSER_CDP_PORT
+
+    if port <= 0 or port > 65535:
+        logger.warning(
+            "Out-of-range EIGENT_LOGIN_BROWSER_CDP_PORT=%s; using default %s",
+            raw_port,
+            DEFAULT_LOGIN_BROWSER_CDP_PORT,
+        )
+        return DEFAULT_LOGIN_BROWSER_CDP_PORT
+
+    return port
+
+
 def _set_connected_cdp_browser(
     endpoint: str,
     *,
@@ -271,21 +303,20 @@ async def launch_cdp_browser(request: Request):
             "endpoint": browser.get("endpoint"),
         }
 
-    port = DEFAULT_CDP_PORT
-    launched = ensure_cdp_browser_available(port)
-    if not launched:
-        if _is_port_in_use(port):
+    endpoint = ensure_cdp_browser_endpoint(DEFAULT_CDP_PORT)
+    if not endpoint:
+        if _is_port_in_use(DEFAULT_CDP_PORT):
             return {
                 "success": False,
-                "error": f"Port {port} is already in use and is not exposing CDP.",
+                "error": f"Port {DEFAULT_CDP_PORT} is already in use and is not exposing a compatible CDP browser.",
             }
         return {
             "success": False,
             "error": "Failed to launch browser. Ensure Chrome/Chromium is installed or run playwright install chromium.",
         }
 
     browser = _set_connected_cdp_browser(
-        f"http://127.0.0.1:{port}",
+        endpoint,
         is_external=False,
     )
     return {
@@ -970,12 +1001,11 @@ async def open_browser_login():
         Browser session information
     """
     try:
-        import socket
         import subprocess
 
         # Use fixed profile name for persistent logins (no port suffix)
         session_id = "user_login"
-        cdp_port = 9223
+        cdp_port = _get_login_browser_cdp_port()
 
         # IMPORTANT: Use dedicated profile for tool_controller browser
         # This is the SOURCE OF TRUTH for login data
@@ -996,12 +1026,7 @@ async def open_browser_login():
             f" at: {user_data_dir}"
         )
 
-        # Check if browser is already running on this port
-        def is_port_in_use(port):
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                return s.connect_ex(("localhost", port)) == 0
-
-        if is_port_in_use(cdp_port):
+        if _is_port_in_use(cdp_port):
             logger.info(f"Browser already running on port {cdp_port}")
             return {
                 "success": True,
@@ -1135,15 +1160,8 @@ def log_electron_output():
 @router.get("/browser/status", name="browser status")
 async def browser_status():
     """Check if the login browser is currently open."""
-    import socket
-
-    cdp_port = 9223
-
-    def is_port_in_use(port):
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            return s.connect_ex(("localhost", port)) == 0
-
-    return {"is_open": is_port_in_use(cdp_port)}
+    cdp_port = _get_login_browser_cdp_port()
+    return {"is_open": _is_port_in_use(cdp_port), "cdp_port": cdp_port}
 
 
 @router.get("/browser/cookies", name="list cookie domains")

backend/app/utils/browser_launcher.py

@@ -20,6 +20,7 @@
 In web mode, Brain launches Chrome/Chromium directly.
 """
 
+import json
 import logging
 import os
 import platform
@@ -32,6 +33,8 @@
 
 # Default CDP port (must match browser_port in Chat model)
 DEFAULT_CDP_PORT = 9222
+FALLBACK_CDP_PORT_START = 9223
+FALLBACK_CDP_PORT_END = 9299
 LOCAL_CDP_HOSTS = frozenset({"127.0.0.1", "localhost", "::1"})
 
 
@@ -66,7 +69,9 @@ def is_cdp_url_available(cdp_url: str) -> bool:
         import httpx
 
         r = httpx.get(f"{normalized}/json/version", timeout=2.0)
-        return r.status_code == 200
+        if r.status_code != 200:
+            return False
+        return _is_supported_cdp_version(r.json(), normalized)
     except Exception:
         return False
 
@@ -78,16 +83,101 @@ def _is_port_in_use(port: int) -> bool:
 
 
 def _is_cdp_available(port: int) -> bool:
-    """Check if a CDP-capable browser is listening on the port."""
+    """Check if a Playwright-compatible CDP browser is listening."""
     try:
         import httpx
 
         r = httpx.get(f"http://127.0.0.1:{port}/json/version", timeout=2.0)
-        return r.status_code == 200
+        if r.status_code != 200:
+            return False
+        return _is_supported_cdp_version(r.json(), f"http://127.0.0.1:{port}")
     except Exception:
         return False
 
 
+def _is_supported_cdp_version(data: dict, endpoint: str) -> bool:
+    """Reject CDP endpoints that Playwright cannot manage."""
+    browser = str(data.get("Browser") or "")
+    user_agent = str(data.get("User-Agent") or "")
+    websocket_url = data.get("webSocketDebuggerUrl")
+    combined = f"{browser} {user_agent}"
+
+    if not websocket_url:
+        logger.debug(
+            "[BROWSER LAUNCHER] CDP endpoint has no browser websocket"
+        )
+        return False
+
+    if "Electron" in combined:
+        logger.warning(
+            "[BROWSER LAUNCHER] Ignoring Electron DevTools endpoint at %s; "
+            "Browser Agent requires a managed Chrome/Chromium CDP browser.",
+            endpoint,
+        )
+        return False
+
+    if not any(
+        token in combined
+        for token in ("Chrome/", "Chromium", "HeadlessChrome/")
+    ):
+        logger.warning(
+            "[BROWSER LAUNCHER] Ignoring unsupported CDP endpoint at %s: %s",
+            endpoint,
+            browser or user_agent or "unknown browser",
+        )
+        return False
+
+    if not _supports_browser_context_management(str(websocket_url), endpoint):
+        return False
+
+    return True
+
+
+def _supports_browser_context_management(
+    websocket_url: str,
+    endpoint: str,
+) -> bool:
+    """Probe the browser-level CDP socket for Playwright compatibility."""
+    try:
+        from websockets.sync.client import connect
+
+        command = {
+            "id": 1,
+            "method": "Browser.setDownloadBehavior",
+            "params": {"behavior": "default"},
+        }
+        with connect(websocket_url, open_timeout=2, close_timeout=1) as ws:
+            ws.send(json.dumps(command))
+            response = json.loads(ws.recv(timeout=2))
+    except Exception as exc:
+        logger.warning(
+            "[BROWSER LAUNCHER] Could not validate CDP capabilities at %s: %s",
+            endpoint,
+            exc,
+        )
+        return False
+
+    error = response.get("error")
+    if error:
+        message = error.get("message") if isinstance(error, dict) else error
+        logger.warning(
+            "[BROWSER LAUNCHER] Ignoring CDP endpoint at %s; "
+            "it does not support browser context management: %s",
+            endpoint,
+            message,
+        )
+        return False
+
+    return True
+
+
+def _candidate_ports(preferred_port: int):
+    yield preferred_port
+    for port in range(FALLBACK_CDP_PORT_START, FALLBACK_CDP_PORT_END + 1):
+        if port != preferred_port:
+            yield port
+
+
 def _find_chrome_executable() -> str | None:
     """Find Chrome or Chromium executable for launching with CDP."""
     system = platform.system()
@@ -252,3 +342,36 @@ def ensure_cdp_browser_available(port: int = DEFAULT_CDP_PORT) -> bool:
         "[BROWSER LAUNCHER] Browser launched but CDP not ready after 10s"
     )
     return False
+
+
+def ensure_cdp_browser_endpoint(
+    preferred_port: int = DEFAULT_CDP_PORT,
+) -> str | None:
+    """
+    Ensure a managed CDP browser exists and return its endpoint.
+
+    If the preferred port is occupied by Electron's own DevTools endpoint, use
+    the next available local port instead of handing that endpoint to
+    Playwright.
+    """
+    for port in _candidate_ports(preferred_port):
+        if _is_cdp_available(port):
+            return f"http://127.0.0.1:{port}"
+
+        if _is_port_in_use(port):
+            logger.warning(
+                "[BROWSER LAUNCHER] Port %s is occupied by a non-managed "
+                "or unsupported CDP endpoint; trying another port.",
+                port,
+            )
+            continue
+
+        if ensure_cdp_browser_available(port):
+            return f"http://127.0.0.1:{port}"
+
+    logger.error(
+        "[BROWSER LAUNCHER] No available CDP browser port in %s-%s",
+        preferred_port,
+        FALLBACK_CDP_PORT_END,
+    )
+    return None