delete openmybrowser

Author: Pakchoioioi

backend/app/controller/tool_controller.py

@@ -44,13 +44,6 @@ class BrowserConnectRequest(BaseModel):
     connected_ports: list[int] = Field(default_factory=list)
 
 
-class BrowserLaunchChromeRequest(BaseModel):
-    r"""Request model for launching user's Chrome with a specific profile."""
-
-    profile_directory: str = Field(
-        description="Chrome profile directory name, e.g. 'Default' or 'Profile 1'"
-    )
-
 
 logger = logging.getLogger("tool_controller")
 router = APIRouter()
@@ -148,77 +141,6 @@ def _find_chromium_executable() -> str | None:
     return None
 
 
-def _find_system_chrome() -> str | None:
-    """Find the user's installed Google Chrome executable path."""
-    system = pf.system()
-
-    if system == "Darwin":
-        chrome_path = (
-            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
-        )
-        if os.path.exists(chrome_path):
-            return chrome_path
-    elif system == "Linux":
-        import shutil
-
-        for name in ("google-chrome", "google-chrome-stable"):
-            found = shutil.which(name)
-            if found:
-                return found
-    elif system == "Windows":
-        candidates = [
-            os.path.join(
-                os.environ.get("PROGRAMFILES", "C:\\Program Files"),
-                "Google",
-                "Chrome",
-                "Application",
-                "chrome.exe",
-            ),
-            os.path.join(
-                os.environ.get(
-                    "PROGRAMFILES(X86)",
-                    "C:\\Program Files (x86)",
-                ),
-                "Google",
-                "Chrome",
-                "Application",
-                "chrome.exe",
-            ),
-        ]
-        for p in candidates:
-            if os.path.exists(p):
-                return p
-
-    return None
-
-
-def _get_chrome_user_data_dir() -> str | None:
-    """Get the Chrome user data directory path for the current platform."""
-    home = os.path.expanduser("~")
-    system = pf.system()
-
-    if system == "Darwin":
-        d = os.path.join(
-            home,
-            "Library",
-            "Application Support",
-            "Google",
-            "Chrome",
-        )
-    elif system == "Linux":
-        d = os.path.join(home, ".config", "google-chrome")
-    elif system == "Windows":
-        local_app = os.environ.get(
-            "LOCALAPPDATA",
-            os.path.join(home, "AppData", "Local"),
-        )
-        d = os.path.join(local_app, "Google", "Chrome", "User Data")
-    else:
-        return None
-
-    return d if os.path.isdir(d) else None
-
-
 @router.post("/install/tool/{tool}", name="install tool")
 async def install_tool(tool: str):
     """
@@ -1100,175 +1022,6 @@ async def launch_cdp_browser():
         )
 
 
-@router.post(
-    "/browser/launch-chrome",
-    name="launch user Chrome with profile",
-)
-async def launch_chrome_with_profile(
-    request: BrowserLaunchChromeRequest,
-):
-    """
-    Launch the user's installed Google Chrome with a specific
-    profile and CDP remote debugging enabled.
-
-    Args:
-        request.profile_directory: Chrome profile dir name
-            (e.g. 'Default', 'Profile 1')
-
-    Returns:
-        success: Whether the launch was successful
-        port: The assigned CDP port number
-        data: Browser CDP info (from /json/version)
-    """
-    try:
-        import asyncio
-        import shutil
-
-        import httpx
-
-        # 1. Find system Chrome
-        chrome_executable = _find_system_chrome()
-        if not chrome_executable:
-            raise HTTPException(
-                status_code=404,
-                detail="Google Chrome is not installed on this system",
-            )
-
-        # 2. Verify Chrome user data directory exists
-        chrome_user_data_dir = _get_chrome_user_data_dir()
-        if not chrome_user_data_dir:
-            raise HTTPException(
-                status_code=404,
-                detail="Chrome user data directory not found",
-            )
-
-        # 3. Verify the requested profile exists
-        profile_path = os.path.join(
-            chrome_user_data_dir, request.profile_directory
-        )
-        if not os.path.isdir(profile_path):
-            raise HTTPException(
-                status_code=404,
-                detail=(f"Profile '{request.profile_directory}' not found"),
-            )
-
-        # 4. Find available port
-        port = _find_available_cdp_port()
-        if port is None:
-            raise HTTPException(
-                status_code=503,
-                detail=(
-                    "No available port found in range"
-                    f" {_CDP_LAUNCH_PORT_START}-{_CDP_PORT_END}"
-                ),
-            )
-
-        logger.info(
-            "[CHROME LAUNCH] Launching Chrome profile"
-            f" '{request.profile_directory}' on port {port}"
-        )
-
-        # 5. Chrome refuses CDP on its default data dir, so
-        #    create a wrapper dir and symlink the real profile.
-        wrapper_dir = os.path.join(
-            os.path.expanduser("~"),
-            ".eigent",
-            "chrome_cdp",
-        )
-        os.makedirs(wrapper_dir, exist_ok=True)
-
-        # Symlink requested profile into wrapper
-        link_dst = os.path.join(wrapper_dir, request.profile_directory)
-        real_profile = os.path.join(
-            chrome_user_data_dir, request.profile_directory
-        )
-        if os.path.islink(link_dst):
-            os.remove(link_dst)
-        elif os.path.isdir(link_dst):
-            shutil.rmtree(link_dst)
-        os.symlink(real_profile, link_dst)
-
-        # Copy Local State (small JSON, needed by Chrome)
-        local_state_src = os.path.join(chrome_user_data_dir, "Local State")
-        local_state_dst = os.path.join(wrapper_dir, "Local State")
-        if os.path.isfile(local_state_src):
-            shutil.copy2(local_state_src, local_state_dst)
-
-        args = [
-            chrome_executable,
-            f"--remote-debugging-port={port}",
-            f"--user-data-dir={wrapper_dir}",
-            f"--profile-directory={request.profile_directory}",
-            "--no-first-run",
-            "--no-default-browser-check",
-        ]
-
-        process = subprocess.Popen(
-            args,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-
-        _launched_browser_processes[port] = process
-        logger.info(f"[CHROME LAUNCH] Chrome spawned, PID: {process.pid}")
-
-        # 6. Poll for browser readiness (max 8 seconds,
-        #    real Chrome may be slower than Chromium)
-        max_wait = 8.0
-        poll_interval = 0.3
-        start_time = time.time()
-        browser_info = None
-
-        async with httpx.AsyncClient() as client:
-            while time.time() - start_time < max_wait:
-                try:
-                    resp = await client.get(
-                        f"http://localhost:{port}/json/version",
-                        timeout=1.0,
-                    )
-                    if resp.status_code == 200:
-                        browser_info = resp.json()
-                        break
-                except Exception:
-                    pass
-                await asyncio.sleep(poll_interval)
-
-        if browser_info is None:
-            process.kill()
-            _launched_browser_processes.pop(port, None)
-            elapsed = time.time() - start_time
-            raise HTTPException(
-                status_code=409,
-                detail=(f"Chrome failed to start CDP (waited {elapsed:.1f}s)"),
-            )
-
-        elapsed = time.time() - start_time
-        logger.info(
-            f"[CHROME LAUNCH] Chrome ready on port {port} after {elapsed:.1f}s"
-        )
-
-        return {
-            "success": True,
-            "port": port,
-            "data": browser_info,
-            "profile_directory": request.profile_directory,
-            "message": (
-                f"Chrome launched with profile"
-                f" '{request.profile_directory}'"
-                f" on port {port}"
-            ),
-        }
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"[CHROME LAUNCH] Failed: {e}", exc_info=True)
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to launch Chrome: {e!s}",
-        )
-
-
 @router.get("/browser/cookies", name="list cookie domains")
 async def list_cookie_domains(search: str = None):
     """

electron/main/index.ts

@@ -678,96 +678,6 @@ function registerIpcHandlers() {
     }
   );
 
-  // ==================== Chrome Profile Detection ====================
-  ipcMain.handle('get-chrome-profiles', async () => {
-    log.info('[CHROME PROFILES] Detecting Chrome profiles...');
-    try {
-      let chromeUserDataDir: string;
-      const platform = process.platform;
-
-      if (platform === 'darwin') {
-        chromeUserDataDir = path.join(
-          app.getPath('home'),
-          'Library',
-          'Application Support',
-          'Google',
-          'Chrome'
-        );
-      } else if (platform === 'win32') {
-        chromeUserDataDir = path.join(
-          process.env.LOCALAPPDATA ||
-            path.join(app.getPath('home'), 'AppData', 'Local'),
-          'Google',
-          'Chrome',
-          'User Data'
-        );
-      } else if (platform === 'linux') {
-        chromeUserDataDir = path.join(
-          app.getPath('home'),
-          '.config',
-          'google-chrome'
-        );
-      } else {
-        return {
-          success: false,
-          error: `Unsupported platform: ${platform}`,
-          profiles: [],
-        };
-      }
-
-      if (!existsSync(chromeUserDataDir)) {
-        log.warn(
-          `[CHROME PROFILES] Chrome user data directory not found: ${chromeUserDataDir}`
-        );
-        return {
-          success: false,
-          error: 'Chrome is not installed or user data directory not found',
-          profiles: [],
-        };
-      }
-
-      // Read all directories that could be profiles
-      const entries = fs.readdirSync(chromeUserDataDir, {
-        withFileTypes: true,
-      });
-      const profileDirs = entries
-        .filter((entry) => entry.isDirectory())
-        .filter(
-          (entry) =>
-            entry.name === 'Default' || entry.name.startsWith('Profile ')
-        )
-        .map((entry) => entry.name);
-
-      const profiles: { directory: string; name: string }[] = [];
-
-      for (const dir of profileDirs) {
-        const prefsPath = path.join(chromeUserDataDir, dir, 'Preferences');
-        try {
-          if (existsSync(prefsPath)) {
-            const prefsContent = fs.readFileSync(prefsPath, 'utf-8');
-            const prefs = JSON.parse(prefsContent);
-            const profileName = prefs?.profile?.name || dir;
-            profiles.push({ directory: dir, name: profileName });
-          }
-        } catch (err) {
-          log.warn(
-            `[CHROME PROFILES] Failed to read preferences for ${dir}: ${err}`
-          );
-          // Still include the profile with directory name as fallback
-          profiles.push({ directory: dir, name: dir });
-        }
-      }
-
-      log.info(
-        `[CHROME PROFILES] Found ${profiles.length} profile(s): ${JSON.stringify(profiles)}`
-      );
-      return { success: true, profiles, chromeUserDataDir };
-    } catch (error: any) {
-      log.error(`[CHROME PROFILES] Failed to detect profiles: ${error}`);
-      return { success: false, error: error.message, profiles: [] };
-    }
-  });
-
   ipcMain.handle('get-app-version', () => app.getVersion());
   ipcMain.handle('get-backend-port', () => backendPort);
 

electron/preload/index.ts

@@ -174,7 +174,6 @@ contextBridge.exposeInMainWorld('electronAPI', {
       ipcRenderer.off(channel, listener);
     };
   },
-  getChromeProfiles: () => ipcRenderer.invoke('get-chrome-profiles'),
   // Skills
   getSkillsDir: () => ipcRenderer.invoke('get-skills-dir'),
   skillsScan: () => ipcRenderer.invoke('skills-scan'),

src/i18n/locales/en-us/layout.json

@@ -217,15 +217,6 @@
   "restart-to-enable": "Restart to enable",
   "open-new-browser": "Open Blank Browser",
   "open-new-browser-description": "You'll open a fresh browser window, and the agent will operate in it.",
-  "open-my-chrome": "Open My Chrome",
-  "open-my-chrome-description": "Launch your installed Chrome with a selected profile, keeping your login sessions.",
-  "select-chrome-profile": "Select Chrome Profile",
-  "launching-chrome": "Launching Chrome...",
-  "chrome-not-installed": "Google Chrome is not installed on this system.",
-  "no-chrome-profiles": "No Chrome profiles found.",
-  "profile-in-use": "Profile is already in use by another Chrome instance.",
-  "failed-to-launch-chrome": "Failed to launch Chrome",
-  "chrome-launched-with-profile": "Chrome launched with profile \"{{profileName}}\" on port {{port}}",
   "browser-cookies-management": "Browser Cookies Management",
   "connect-existing-browser": "Connect Existing Browser",
   "connect-existing-browser-description": "Connect to a browser already running with CDP enabled on a specific port.",