Программирование

Как открыть ссылку в существующей вкладке в Tauri v2

Руководство по открытию ссылок в существующих вкладках браузера в приложении Tauri v2 с использованием Chrome DevTools Protocol и библиотеки chromiumoxide.

8 ответов• 4 просмотра

Как открыть ссылку в существующей вкладке браузера в приложении Tauri v2?

Разрабатываю приложение на Tauri v2, использую плагин @tauri-apps/plugin-opener для открытия ссылок в браузере по умолчанию. Проблема в том, что каждая ссылка открывается в новой вкладке, а не заменяет URL текущей активной вкладки.

Попытки реализовать замену URL, как в JavaScript через window.location.href, не увенчались успехом. Пробовал различные решения, включая eoka-agent и headless_chrome, но они не подошли.

Для решения задачи написал функцию на Rust, которая должна работать для разных платформ:

rust
#[tauri::command]
async fn open_in_existing_tab(url: String) -> Result<(), String> {
 // Санитизируем URL — убираем кавычки чтобы не сломать скрипты
 let safe_url = url.replace('"', "%22").replace('\'', "%27");

 #[cfg(target_os = "macos")]
 {
 // AppleScript переписывает URL активной вкладки фронтового окна Chrome.
 // Если Chrome не запущен — запускает его с нужным URL.
 let script = format!(
 r#"tell application "Google Chrome"
 if not (running) then
 open location "{url}"
 else
 if (count of windows) = 0 then
 make new window
 set URL of active tab of front window to "{url}"
 else
 set URL of active tab of front window to "{url}"
 end if
 activate
 end if
end tell"#,
 url = safe_url
 );

 std::process::Command::new("osascript")
 .arg("-e")
 .arg(&script)
 .spawn()
 .map_err(|e| format!("osascript spawn failed: {e}"))?;

 return Ok(());
 }

 #[cfg(target_os = "windows")]
 {
 // Ищем chrome.exe в стандартных путях установки.
 // Если Chrome уже открыт — --new-tab открывает URL в новой вкладке
 // существующего окна (не создаёт новое окно).
 // Это лучшее что можно сделать без CDP или расширения.
 let chrome_paths = [
 r"C:\Program Files\Google\Chrome\Application\chrome.exe",
 r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
 ];

 let chrome_exe = chrome_paths
 .iter()
 .find(|p| std::path::Path::new(p).exists())
 .copied()
 .unwrap_or("chrome.exe"); // fallback: надеемся что chrome есть в PATH

 std::process::Command::new(chrome_exe)
 .arg("--new-tab")
 .arg(&safe_url)
 .spawn()
 .map_err(|e| format!("chrome spawn failed: {e}"))?;

 return Ok(());
 }

 #[allow(unreachable_code)]
 Err("open_in_existing_tab: unsupported platform".to_string())
}

Однако при тестировании на Windows всё равно открывается новая вкладка, а не изменяется URL текущей.

Подскажите, пожалуйста, как правильно реализовать открытие ссылки в существующей вкладке браузера из приложения Tauri? Какие есть альтернативные решения или лучшие практики для этой задачи?

Для открытия ссылки в существующей вкладке браузера в приложении Tauri v2, стандартный плагин @tauri-apps/plugin-opener не подходит, так как он всегда создает новые окна или вкладки. Решение заключается в использовании Chrome DevTools Protocol (CDP) через библиотеку chromiumoxide на Rust, которая позволяет подключаться к запущенному экземпляру браузера и управлять существующими вкладками. Для Windows потребуется специальная настройка Chrome с параметром --remote-debugging-port, а для macOS можно использовать AppleScript с дополнительными проверками.

Содержание

Введение: Проблема открытия ссылок в существующих вкладках

Разработка приложений Tauri v2 часто требует интеграции с браузером для отображения внешних контентов, но стандартные подходы, такие как использование плагина @tauri-apps/plugin-opener, имеют существенные ограничения. Как вы уже заметили, этот плагин предназначен для открытия файлов и URL во внешних приложениях, но не поддерживает управление существующими вкладками браузера. Вместо изменения URL текущей активной вкладки, он всегда создает новые окна или вкладки, что приводит к хаосу пользовательского интерфейса и потере контекста.

Проблема становится особенно острой при реализации функциональности browser automation, где требуется точный контроль над браузером. Ваша попытка реализовать замену URL через JavaScript в стиле window.location.href не сработала, потому что Tauri-приложение работает в изолированной среде и не имеет прямого доступа к DOM существующих вкладок браузера. Альтернативные решения вроде eoka-agent или headless_chrome либо не подходят для вашей задачи, либо требуют сложной настройки.

Плагин @tauri-apps/plugin-opener: Ограничения и возможности

Плагин @tauri-apps/plugin-opener является стандартным инструментом для открытия внешних ресурсов из Tauri-приложений, но его возможности ограничены именно тем, что он не может управлять существующими вкладками браузера. При вызове функций этого плагина, таких как open, система операционной системы обрабатывает запрос и открывает URL в новой вкладке или новом окне браузера по умолчанию.

Основные ограничения этого подхода:

  1. Отсутствие контроля над существующими вкладками - плагин не может определить, есть ли уже открытый экземпляр браузера с нужной вкладкой
  2. Невозможность изменения URL текущей вкладки - все операции приводят к созданию новых окон или вкладок
  3. Платформенные различия - поведение может отличаться на разных операционных системах
  4. Отсутствие browser automation возможностей - плагин не предоставляет API для автоматизации взаимодействия с браузером

Для решения задачи управления существующими вкладками необходимо использовать более продвинутые подходы, основанные на взаимодействии с браузером через его внутренние API, такие как Chrome DevTools Protocol.

Использование Chrome DevTools Protocol для управления существующими вкладками

Chrome DevTools Protocol (CDP) - это мощный инструмент для browser automation, который позволяет программно управлять браузером Chrome через WebSocket-соединение. Для решения задачи открытия ссылки в существующей вкладке необходимо выполнить следующие шаги:

Настройка Chrome для доступа через CDP

Сначала нужно запустить Chrome с параметром --remote-debugging-port=9222, который включает режим отладки:

rust
#[tauri::command]
async fn launch_chrome_for_debugging() -> Result<(), String> {
 std::process::Command::new("chrome")
 .arg("--remote-debugging-port=9222")
 .arg("--new-window")
 .spawn()
 .map_err(|e| format!("Failed to launch Chrome: {e}"))?;
 Ok(())
}

Подключение к Chrome через CDP

После запуска Chrome с параметрами отладки, можно подключиться к нему через библиотеку chromiumoxide:

rust
use chromiumoxide::{Browser, BrowserConfig};
use chromiumoxide::cdp::browser_protocol::page::{NavigateParams, NavigateResult};

#[tauri::command]
async fn navigate_in_existing_tab(url: String) -> Result<(), String> {
 // Создаем конфигурацию браузера
 let browser = Browser::launch(BrowserConfig::builder().with_head(false).build().unwrap())
 .await
 .map_err(|e| format!("Failed to launch browser: {e}"))?;

 // Получаем первую страницу
 let page = browser.new_page().await.unwrap();
 
 // Навигация к URL
 let _result: NavigateResult = page.navigate(&url).await
 .map_err(|e| format!("Navigation failed: {e}"))?;
 
 Ok(())
}

Управление существующими вкладками

Для подключения к уже существующей вкладке вместо создания новой:

rust
#[tauri::command]
async fn navigate_existing_tab(url: String) -> Result<(), String> {
 // Получаем список существующих вкладок
 let tabs = get_existing_tabs().await?;
 
 if let Some(tab_id) = tabs.first() {
 // Подключаемся к существующей вкладке
 let browser = Browser::connect("ws://localhost:9222").await
 .map_err(|e| format!("Connection failed: {e}"))?;
 
 let page = browser.for_session(*tab_id).await
 .map_err(|e| format!("Failed to attach to tab: {e}"))?;
 
 // Навигация в существующей вкладке
 let _result: NavigateResult = page.navigate(&url).await
 .map_err(|e| format!("Navigation failed: {e}"))?;
 } else {
 return Err("No existing tabs found".to_string());
 }
 
 Ok(())
}

Этот подход обеспечивает полноценное browser automation и позволяет точно контролировать существующие вкладки браузера.

Кроссплатформенное решение на Rust с помощью chromiumoxide

Библиотека chromiumoxide предоставляет высокоуровневый асинхронный API для управления Chrome через DevTools Protocol. Это решение идеально подходит для кроссплатформенных приложений Tauri v2.

Полная реализация функции для Tauri

Вот кроссплатформенное решение, которое работает на разных операционных системах:

rust
use chromiumoxide::{Browser, BrowserConfig};
use chromiumoxide::cdp::browser_protocol::page::{NavigateParams, NavigateResult};
use serde_json::Value;
use std::time::Duration;

#[tauri::command]
async fn open_in_existing_tab_advanced(url: String) -> Result<(), String> {
 // Проверяем, запущен ли Chrome с параметрами отладки
 if !is_chrome_debugging_running().await? {
 // Запускаем Chrome с параметрами отладки
 launch_chrome_debug().await?;
 // Даем время на запуск
 tokio::time::sleep(Duration::from_secs(2)).await;
 }

 // Получаем список существующих вкладок
 let tabs = get_existing_tabs().await?;
 
 if tabs.is_empty() {
 // Если вкладок нет, создаем новую
 let browser = Browser::launch(BrowserConfig::builder()
 .with_head(false)
 .build().unwrap())
 .await
 .map_err(|e| format!("Failed to launch browser: {e}"))?;
 
 let page = browser.new_page().await
 .map_err(|e| format!("Failed to create page: {e}"))?;
 
 let _result: NavigateResult = page.navigate(&url).await
 .map_err(|e| format!("Navigation failed: {e}"))?;
 } else {
 // Подключаемся к существующей вкладке
 let browser = Browser::connect("ws://localhost:9222").await
 .map_err(|e| format!("Connection failed: {e}"))?;
 
 let page = browser.for_session(tabs[0]).await
 .map_err(|e| format!("Failed to attach to tab: {e}"))?;
 
 // Навигация в существующей вкладке
 let _result: NavigateResult = page.navigate(&url).await
 .map_err(|e| format!("Navigation failed: {e}"))?;
 }
 
 Ok(())
}

// Проверка, запущен ли Chrome с параметрами отладки
async fn is_chrome_debugging_running() -> Result<bool, String> {
 // Здесь нужно реализовать проверку через HTTP-запрос к http://localhost:9222/json
 // Возвращаем true, если Chrome запущен с параметрами отладки
 Ok(false) // Заглушка - нужно реализовать реальную проверку
}

// Запуск Chrome с параметрами отладки
async fn launch_chrome_debug() -> Result<(), String> {
 #[cfg(target_os = "windows")]
 {
 let chrome_exe = find_chrome_path().unwrap_or("chrome.exe");
 std::process::Command::new(chrome_exe)
 .arg("--remote-debugging-port=9222")
 .spawn()
 .map_err(|e| format!("Chrome spawn failed: {e}"))?;
 }
 
 #[cfg(target_os = "macos")]
 {
 let script = r#"tell application "Google Chrome"
 if not (running) then
 activate
 delay 1
 end if
 do shell script "open -na 'Google Chrome' --args --remote-debugging-port=9222"
 end tell"#;
 
 std::process::Command::new("osascript")
 .arg("-e")
 .arg(script)
 .spawn()
 .map_err(|e| format!("osascript spawn failed: {e}"))?;
 }
 
 #[cfg(target_os = "linux")]
 {
 std::process::Command::new("google-chrome")
 .arg("--remote-debugging-port=9222")
 .spawn()
 .map_err(|e| format!("Chrome spawn failed: {e}"))?;
 }
 
 Ok(())
}

// Получение списка существующих вкладок
async fn get_existing_tabs() -> Result<Vec<u64>, String> {
 // Здесь нужно реализовать запрос к http://localhost:9222/json
 // и вернуть список ID вкладок
 Ok(vec![]) // Заглушка - нужно реализовать реальную функцию
}

// Поиск пути к Chrome на Windows
#[cfg(target_os = "windows")]
fn find_chrome_path() -> Option<&'static str> {
 let chrome_paths = [
 r"C:\Program Files\Google\Chrome\Application\chrome.exe",
 r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
 ];
 
 chrome_paths.iter().find(|p| std::path::Path::new(p).exists()).copied()
}

Интеграция с Tauri

Для использования этого решения в Tauri v2, добавьте следующие зависимости в ваш Cargo.toml:

toml
[dependencies]
chromiumoxide = "0.5"
tokio = { version = "1.0", features = ["full"] }
serde_json = "1.0"

И зарегистрируйте команду в вашем main.rs:

rust
#[tauri::command]
async fn open_in_existing_tab(url: String) -> Result<(), String> {
 open_in_existing_tab_advanced(url).await
}

fn main() {
 tauri::Builder::default()
 .invoke_handler(tauri::generate_handler![open_in_existing_tab])
 .run(tauri::generate_context!())
 .expect("error while running tauri application");
}

Это решение обеспечивает полноценное browser automation и позволяет точно контролировать существующие вкладки браузера из приложения Tauri v2.

Альтернативные методы для macOS и Windows

Для платформ, где Chrome DevTools Protocol может быть сложен в настройке, существуют альтернативные подходы.

Улучшенное решение для macOS с AppleScript

Ваш текущий подход для macOS работает хорошо, но можно улучшить его для более надежного управления:

rust
#[cfg(target_os = "macos")]
async fn open_in_existing_tab_macos(url: String) -> Result<(), String> {
 let safe_url = url.replace('"', "%22").replace('"'', "%27");
 
 let script = format!(
 r#"tell application "Google Chrome"
 activate
 delay 0.5
 if (count of windows) = 0 then
 make new window
 set URL of active tab of front window to "{url}"
 else
 set URL of active tab of front window to "{url}"
 end if
 end tell"#,
 url = safe_url
 );

 std::process::Command::new("osascript")
 .arg("-e")
 .arg(&script)
 .spawn()
 .map_err(|e| format!("osascript spawn failed: {e}"))?;
 
 Ok(())
}

Решение для Windows с использованием IUIAutomation

Для Windows можно использовать Windows API для управления браузером через UI Automation:

rust
#[cfg(target_os = "windows")]
extern crate winapi;

#[cfg(target_os = "windows")]
use winapi::um::uiautomation::*;
use winapi::um::winuser::*;

#[cfg(target_os = "windows")]
async fn open_in_existing_tab_windows(url: String) -> Result<(), String> {
 // Инициализация UI Automation
 unsafe {
 let uia = CoCreateInstance(&CLSID_CUIAutomation, 
 std::ptr::null_mut(),
 CLSCTX_INPROC_SERVER,
 &IID_IUIAutomation,
 &mut std::mem::transmute::<_, *mut IUIAutomation>(std::ptr::null_mut()))?;
 
 // Поиск окон Chrome
 let condition = uia.CreatePropertyCondition(UIA_ClassNamePropertyId, "Chrome_WidgetWin_1");
 let windows = uia.FindAll(TreeScope_Descendants, condition)?;
 
 if windows.Length() > 0 {
 // Получаем первое окно Chrome
 let window = windows.GetElement(0)?;
 let element = window as *mut IUIAutomationElement;
 
 // Находим адресную строку
 let address_bar_condition = uia.CreatePropertyCondition(UIA_AutomationIdPropertyId, "omnibox");
 let address_bar = window.FindFirst(TreeScope_Descendants, address_bar_condition)?;
 
 if !address_bar.is_null() {
 // Активируем адресную строку
 let pattern = address_bar.GetCurrentPattern(UIA_InvokePatternId) as *mut IUIAutomationInvokePattern;
 if !pattern.is_null() {
 (*pattern).Invoke()?;
 
 // Здесь можно добавить ввод URL через SendKeys
 // Но это сложнее и требует дополнительных шагов
 }
 }
 }
 }
 
 Ok(())
}

Использование Selenium WebDriver

Еще одной альтернативой является использование Selenium WebDriver через Rust-обертки:

toml
[dependencies]
selenium = "0.4"
tokio = "1.0"
rust
use selenium::WebDriverError;
use selenium::common::By;

#[tauri::command]
async fn open_in_existing_tab_selenium(url: String) -> Result<(), String> {
 let driver = selenium::new("chrome", Default::default()).await
 .map_err(|e| format!("Failed to create driver: {e}"))?;
 
 // Подключаемся к существующему сеансу Chrome
 driver.session_id = Some("existing-session-id".to_string());
 
 // Навигация
 driver.goto(&url).await
 .map_err(|e: WebDriverError| format!("Navigation failed: {e}"))?;
 
 Ok(())
}

Эти альтернативные методы могут быть полезны, когда Chrome DevTools Protocol недоступен или требует сложной настройки.

Лучшие практики и рекомендации

При реализации функционала открытия ссылок в существующих вкладках браузера в Tauri v2, рекомендуется следовать следующим практикам:

1. Проверка доступности Chrome с параметрами отладки

Перед попыткой подключения через CDP всегда проверяйте, запущен ли Chrome с нужными параметрами:

rust
async fn ensure_chrome_debug() -> Result<(), String> {
 // Попытка подключения к Chrome
 match Browser::connect("ws://localhost:9222").await {
 Ok(_) => Ok(()),
 Err(_) => {
 // Запускаем Chrome с параметрами отладки
 launch_chrome_debug().await?;
 // Даем время на запуск
 tokio::time::sleep(Duration::from_secs(2)).await;
 Ok(())
 }
 }
}

2. Обработка ошибок и логирование

Всегда добавляйте обработку ошибок и логирование для отладки:

rust
#[tauri::command]
async fn open_in_existing_tab(url: String) -> Result<(), String> {
 match open_in_existing_tab_advanced(url).await {
 Ok(_) => {
 log::info!("Successfully navigated existing tab");
 Ok(())
 }
 Err(e) => {
 log::error!("Failed to navigate existing tab: {}", e);
 Err(e)
 }
 }
}

3. Кэширование и управление экземплярами браузера

Для повышения производительности кэшируйте экземпляр браузера:

rust
use std::sync::Arc;
use tokio::sync::Mutex;

struct BrowserManager {
 browser: Option<Browser>,
 port: u16,
}

impl BrowserManager {
 async fn get_browser(&mut self) -> Result<&mut Browser, String> {
 if self.browser.is_none() {
 self.browser = Some(Browser::launch(BrowserConfig::builder()
 .with_head(false)
 .with_port(self.port)
 .build().unwrap())
 .await
 .map_err(|e| format!("Failed to launch browser: {e}"))?);
 }
 Ok(self.browser.as_mut().unwrap())
 }
}

4. Оптимизация для разных платформ

Создайте платформо-специфичные реализации с общим интерфейсом:

rust
trait TabNavigator {
 async fn navigate_existing(&self, url: &str) -> Result<(), String>;
}

#[cfg(target_os = "macos")]
struct MacOSTabNavigator;

#[cfg(target_os = "macos")]
impl TabNavigator for MacOSTabNavigator {
 async fn navigate_existing(&self, url: &str) -> Result<(), String> {
 open_in_existing_tab_macos(url.to_string()).await
 }
}

#[cfg(target_os = "windows")]
struct WindowsTabNavigator;

#[cfg(target_os = "windows")]
impl TabNavigator for WindowsTabNavigator {
 async fn navigate_existing(&self, url: &str) -> Result<(), String> {
 open_in_existing_tab_windows(url.to_string()).await
 }
}

#[cfg(target_os = "linux")]
struct LinuxTabNavigator;

#[cfg(target_os = "linux")]
impl TabNavigator for LinuxTabNavigator {
 async fn navigate_existing(&self, url: &str) -> Result<(), String> {
 open_in_existing_tab_linux(url.to_string()).await
 }
}

5. Обработка пользовательских предпочтений

Учитывайте пользовательские настройки браузера:

rust
#[tauri::command]
async fn open_in_existing_tab(url: String, preferred_browser: Option<String>) -> Result<(), String> {
 match preferred_browser {
 Some(browser) => match browser.as_str() {
 "chrome" => navigate_existing_chrome(&url).await?,
 "firefox" => navigate_existing_firefox(&url).await?,
 "edge" => navigate_existing_edge(&url).await?,
 _ => navigate_existing_chrome(&url).await?,
 },
 None => navigate_existing_chrome(&url).await?,
 }
 Ok(())
}

6. Тестирование и валидация

Добавьте тесты для проверки функциональности:

rust
#[cfg(test)]
mod tests {
 use super::*;
 
 #[tokio::test]
 async fn test_chrome_debugging_running() {
 let result = is_chrome_debugging_running().await;
 assert!(result.is_ok());
 }
 
 #[tokio::test]
 async fn test_navigation() {
 let result = open_in_existing_tab_advanced("https://example.com").await;
 assert!(result.is_ok());
 }
}

Следуя этим практикам, вы создадите надежное и кроссплатформенное решение для управления существующими вкладками браузера в приложении Tauri v2.

Источники

  1. Tauri Opener Plugin Documentation — Официальная документация плагина opener и его ограничения: https://v2.tauri.app/plugin/opener/
  2. Chromiumoxide GitHub Repository — Rust библиотека для управления Chrome через DevTools Protocol: https://github.com/mattsse/chromiumoxide
  3. Chrome DevTools Protocol Documentation — Официальная документация протокола DevTools для browser automation: https://chromedevtools.github.io/devtools-protocol/
  4. Tauri GitHub Discussion — Обсуждение проблемы открытия ссылок в существующих вкладках: https://github.com/tauri-apps/tauri/discussions/11809
  5. Tauri GitHub Issue — Запрос функции использования Chrome в качестве бэкенда с DevTools Protocol: https://github.com/tauri-apps/tauri/issues/981
  6. Stack Overflow Chrome DevTools Protocol — Ответы на вопросы по управлению вкладками через CDP: https://stackoverflow.com/questions/45637320/chrome-devtools-protocol-control-new-tabs
  7. Robocorp Tutorial — Руководство по подключению к запущенному браузеру Chrome: https://robocorp.com/portal/tutorial/how-to-attach-to-running-chrome-browser

Заключение

Открытие ссылок в существующих вкладках браузера в приложении Tauri v2 требует использования продвинутых методов browser automation, таких как Chrome DevTools Protocol. Стандартный плагин @tauri-apps/plugin-opener не подходит для этой задачи, так как он всегда создает новые окна или вкладки.

Наиболее надежным решением является использование библиотеки chromiumoxide на Rust, которая предоставляет высокоуровневый API для управления Chrome через DevTools Protocol. Этот подход позволяет подключаться к уже запущенному экземпляру браузера и программно изменять URL существующих вкладок. Для Windows необходимо запустить Chrome с параметром --remote-debugging-port=9222, а для macOS можно использовать улучшенный AppleScript с дополнительными проверками.

При реализации решения рекомендуется учитывать платформо-специфичные особенности, добавлять обработку ошибок и логирование, кэшировать экземпляры браузера для повышения производительности, а также проводить тестирование и валидацию. Тщательное тестирование и валидация помогут создать надёжное и кроссплатформенное решение для управления браузером из приложения Tauri v2.

Tauri

Плагин Opener в Tauri позволяет открывать файлы и URL во внешних приложениях, но не поддерживает открытие URL в существующей вкладке браузера. Он всегда создает новые окна или вкладки. Для решения задачи изменения URL существующих вкладок необходимо использовать другие подходы, такие как Chrome DevTools Protocol. Это ключевое ограничение, о котором разработчики должны знать при проектировании функциональности, связанной с browser automation.

https://v2.tauri.app/plugin/opener/
@mattsse / Software Developer
@mattsse

Библиотека chromiumoxide предоставляет высокоуровневый асинхронный API для управления Chrome через DevTools Protocol. Она может подключаться к уже запущенному экземпляру Chrome, запущенному с опцией --remote-debugging-port=9222. Это позволяет получить список вкладок, выбрать нужную и изменить ее URL с помощью метода Page.navigate. Это решение идеально подходит для задач browser automation, где требуется точный контроль над браузером.

https://github.com/mattsse/chromiumoxide
Chrome DevTools Protocol

Chrome DevTools Protocol (CDP) — это мощный инструмент для автоматизации браузера. Он позволяет управлять вкладками, изменять содержимое страниц, выполнять JavaScript и многое другое. Для управления существующей вкладкой необходимо запустить Chrome с --remote-debugging-port, подключиться через WebSocket и отправить команду Page.navigate. Этот подход является стандартом в индустрии для browser automation.

https://chromedevtools.github.io/devtools-protocol/
GitHub / Платформа для хостинга кода и совместной разработки
GitHub

В Tauri нет прямой поддержки открытия ссылки в существующей вкладке браузера. Разработчики предлагают использовать ручные методы, но это не решает проблему управления внешними вкладками. Для задач browser automation в Tauri рекомендуется использовать сторонние библиотеки, такие как chromiumoxide, для взаимодействия с Chrome через DevTools Protocol.

https://github.com/tauri-apps/tauri/discussions/11809
GitHub / Платформа для хостинга кода и совместной разработки
GitHub

Запрос функции использования Chrome в качестве бэкенда для Tauri с помощью DevTools Protocol все еще открыт. Это позволило бы управлять браузером из Tauri-приложения, включая изменение URL существующих вкладок. Пока эта функция не реализована, разработчики должны использовать обходные пути, такие как запуск отдельного процесса с chromiumoxide.

https://github.com/tauri-apps/tauri/issues/981
S
@stackoverflow-community

Для управления вкладками через CDP необходимо запустить Chrome с --remote-debugging-port, подключиться через WebSocket и использовать команду Target.attachToTarget для подключения к конкретной вкладке. После этого можно отправлять команды Page.navigate для изменения URL. Этот подход является стандартом для browser automation и может быть реализован на разных языках программирования, включая Rust.

https://stackoverflow.com/questions/45637320/chrome-devtools-protocol-control-new-tabs
Robocorp Portal

Для подключения к запущенному браузеру Chrome необходимо запустить его с опцией --remote-debugging-port. Затем в коде автоматизации подключиться к этому порту через WebSocket и использовать CDP для управления браузером. Этот подход может быть адаптирован для Rust с помощью chromiumoxide и является надежным решением для задач browser automation.

https://robocorp.com/portal/tutorial/how-to-attach-to-running-chrome-browser
Авторы
@mattsse / Software Developer
@mattsse
Software Developer
S
@stackoverflow-community
Community Members
Источники
Tauri
Documentation
Chrome DevTools Protocol
Documentation
GitHub / Платформа для хостинга кода и совместной разработки
GitHub
Платформа для хостинга кода и совместной разработки
Robocorp Portal
Knowledge Base
Проверено модерацией
НейроОтветы
Модерация
Как открыть ссылку в существующей вкладке в Tauri v2