Refactor fetch_html to use shared session browser code

Replaces the duplicate browser launch/wait/extract logic in fetch_html
with calls to session::launch_browser and session::extract_page_content.
Deletes fetch_with_browser entirely. fetch_html is now a thin wrapper:
launch → extract → tear down, using the same code path as persistent
browser sessions.

https://claude.ai/code/session_01QvEcr1eaxtqwA2Ry5DGwhp

Author: claude

src/tools/browser/mod.rs

@@ -35,11 +35,6 @@ pub mod session;
 use std::fs;
 use std::path::Path;
 use std::sync::OnceLock;
-use std::time::Duration;
-
-use chromiumoxide::browser::{Browser, BrowserConfig, HeadlessMode};
-use chromiumoxide::handler::viewport::Viewport;
-use futures::StreamExt;
 
 use crate::config::BrowserConfig as AppBrowserConfig;
 
@@ -163,11 +158,9 @@ fn which_browser(name: &str) -> Option<String> {
 
 /// Fetch HTML content using headless browser and convert to readable markdown
 ///
-/// This function:
-/// 1. Requires Chrome/Chromium to be installed
-/// 2. Renders page with headless browser (handles SPAs/JS)
-/// 3. Applies readability algorithm to extract main content
-/// 4. Converts to markdown for token-efficient representation
+/// This is the one-shot convenience function. It launches a browser, navigates,
+/// waits for the page to settle, extracts readable content, and tears down the
+/// browser — all using the same code path as persistent browser sessions.
 ///
 /// Browser settings (executable path, profile) are read from the global
 /// BrowserContext initialized at app startup.
@@ -184,30 +177,21 @@ pub async fn fetch_html(url: &str, max_length: Option<usize>) -> Result<FetchHtm
         ));
     }
 
-    // Get browser settings from global context
-    let ctx = browser_context();
-
-    // Resolve browser executable: context -> auto-detect
-    let browser_path = ctx
-        .and_then(|c| c.chrome_executable.clone())
-        .or_else(detect_browser)
-        .ok_or_else(|| {
-            "No Chrome/Chromium browser found. Install chromium or google-chrome to use this tool."
-                .to_string()
-        })?;
-
-    // Get settings from context
-    let ctx = ctx.cloned().unwrap_or_default();
+    // Launch browser, navigate, wait for settle — shared with session module
+    let (mut browser, page, handler_task, temp_dir) = session::launch_browser(url).await?;
 
-    let html = fetch_with_browser(url, &browser_path, &ctx).await?;
+    // Extract content
+    let content = session::extract_page_content(&page, url).await?;
 
-    // Apply readability to extract main content
-    let readable = extract_readable_content(&html, url)?;
-
-    // Convert to markdown
-    let mut markdown = html_to_markdown(&readable.content);
+    // Tear down immediately (one-shot, no persistent session)
+    let _ = browser.close().await;
+    handler_task.abort();
+    if let Some(ref temp) = temp_dir {
+        let _ = std::fs::remove_dir_all(temp);
+    }
 
     // Truncate if needed
+    let mut markdown = content.markdown;
     if markdown.len() > max_length {
         let mut end = max_length;
         while end > 0 && !markdown.is_char_boundary(end) {
@@ -223,185 +207,11 @@ pub async fn fetch_html(url: &str, max_length: Option<usize>) -> Result<FetchHtm
 
     Ok(FetchHtmlResult {
         content: markdown,
-        title: readable.title,
+        title: content.title,
         url: url.to_string(),
     })
 }
 
-/// Fetch page using headless browser (handles JavaScript rendering)
-///
-/// # Arguments
-/// * `url` - The URL to fetch
-/// * `browser_path` - Path to Chrome/Chromium executable
-/// * `ctx` - Browser context with profile, viewport, and timing settings
-async fn fetch_with_browser(
-    url: &str,
-    browser_path: &str,
-    ctx: &BrowserContext,
-) -> Result<String, String> {
-    // Copy profile to isolated temp directory to avoid SingletonLock conflicts.
-    // See module doc comment for full explanation of why this is necessary.
-    let temp_dir = if let (Some(data_dir), Some(prof)) =
-        (&ctx.chrome_user_data_dir, &ctx.chrome_profile)
-    {
-        let source_profile = std::path::Path::new(data_dir).join(prof);
-        if source_profile.exists() {
-            // Use PID to isolate temp dirs between concurrent Codey instances
-            let temp_base =
-                std::env::temp_dir().join(format!("codey-browser-{}", std::process::id()));
-            // Clean up any previous temp dir to ensure fresh copy
-            if temp_base.exists() {
-                let _ = std::fs::remove_dir_all(&temp_base);
-            }
-            std::fs::create_dir_all(&temp_base)
-                .map_err(|e| format!("Failed to create temp browser dir: {}", e))?;
-
-            // Copy profile to temp_base/Default (becomes the default profile)
-            let dest_profile = temp_base.join("Default");
-            copy_dir_recursive(&source_profile, &dest_profile)
-                .map_err(|e| format!("Failed to copy browser profile: {}", e))?;
-
-            Some(temp_base)
-        } else {
-            return Err(format!(
-                "Browser profile not found: {}",
-                source_profile.display()
-            ));
-        }
-    } else {
-        None
-    };
-
-    // Configure browser
-    let headless_mode = if ctx.headless {
-        HeadlessMode::True
-    } else {
-        HeadlessMode::False
-    };
-
-    // When using a copied profile, we need real Keychain access to decrypt cookies.
-    //
-    // chromiumoxide's DEFAULT_ARGS (from Puppeteer) include:
-    //   "--password-store=basic"  - Uses basic password store instead of OS keychain
-    //   "--use-mock-keychain"     - Uses mock keychain for testing
-    //
-    // These flags are designed for automation/testing where you don't want system prompts,
-    // but they prevent Chrome from decrypting cookies that were encrypted with the real
-    // Keychain key. We must disable defaults and provide our own args list.
-    //
-    // Reference: chromiumoxide 0.7.0 browser.rs DEFAULT_ARGS
-    // Original source: https://github.com/nickelc/chromiumoxide/blob/v0.7.0/src/browser.rs
-    let using_profile = temp_dir.is_some();
-
-    let mut config = BrowserConfig::builder()
-        .no_sandbox()
-        .headless_mode(headless_mode)
-        .window_size(ctx.viewport_width, ctx.viewport_height)
-        .viewport(Viewport {
-            width: ctx.viewport_width,
-            height: ctx.viewport_height,
-            device_scale_factor: None,
-            emulating_mobile: false,
-            is_landscape: false,
-            has_touch: false,
-        });
-
-    if using_profile {
-        // Disable chromiumoxide defaults and add our own (without mock keychain flags)
-        config = config.disable_default_args().args([
-            "--disable-background-networking",
-            "--enable-features=NetworkService,NetworkServiceInProcess",
-            "--disable-background-timer-throttling",
-            "--disable-backgrounding-occluded-windows",
-            "--disable-breakpad",
-            "--disable-client-side-phishing-detection",
-            "--disable-component-extensions-with-background-pages",
-            "--disable-default-apps",
-            "--disable-dev-shm-usage",
-            "--disable-extensions",
-            "--disable-features=TranslateUI",
-            "--disable-hang-monitor",
-            "--disable-ipc-flooding-protection",
-            "--disable-popup-blocking",
-            "--disable-prompt-on-repost",
-            "--disable-renderer-backgrounding",
-            "--disable-sync",
-            "--force-color-profile=srgb",
-            "--metrics-recording-only",
-            "--no-first-run",
-            "--enable-automation",
-            // OMITTED: "--password-store=basic" - need real password store for cookies
-            // OMITTED: "--use-mock-keychain" - need real Keychain access
-            "--enable-blink-features=IdleDetection",
-            "--lang=en_US",
-            "--disable-gpu",
-        ]);
-    } else {
-        config = config.arg("--disable-gpu");
-    }
-
-    config = config.chrome_executable(browser_path);
-
-    // Use temp dir if we copied a profile, otherwise use user_data_dir directly
-    if let Some(ref temp) = temp_dir {
-        config = config.user_data_dir(temp);
-    } else if let Some(ref dir) = ctx.chrome_user_data_dir {
-        // Fallback: use user_data_dir directly (may conflict with running Chrome)
-        config = config.user_data_dir(dir);
-        if let Some(ref prof) = ctx.chrome_profile {
-            config = config.arg(format!("--profile-directory={}", prof));
-        }
-    }
-
-    let config = config
-        .build()
-        .map_err(|e| format!("Failed to configure browser: {:?}", e))?;
-
-    // Launch browser with timeout
-    let launch_result =
-        tokio::time::timeout(Duration::from_secs(30), Browser::launch(config)).await;
-
-    let (mut browser, mut handler) = match launch_result {
-        Ok(Ok((browser, handler))) => (browser, handler),
-        Ok(Err(e)) => return Err(format!("Failed to launch browser: {}", e)),
-        Err(_) => return Err("Browser launch timed out after 30 seconds".to_string()),
-    };
-
-    // Spawn handler task (required by chromiumoxide)
-    let handle = tokio::spawn(async move {
-        while let Some(_event) = handler.next().await {
-            // Process browser events
-        }
-    });
-
-    // Navigate to page
-    let page_result = tokio::time::timeout(Duration::from_secs(60), async {
-        let page = browser
-            .new_page(url)
-            .await
-            .map_err(|e| format!("Failed to navigate: {}", e))?;
-
-        // Wait for JavaScript to render (configurable for SPAs like Twitter)
-        tokio::time::sleep(Duration::from_millis(ctx.page_load_wait_ms)).await;
-
-        // Get rendered HTML
-        page.content()
-            .await
-            .map_err(|e| format!("Failed to get page content: {}", e))
-    })
-    .await;
-
-    // Clean up
-    let _ = browser.close().await;
-    handle.abort();
-
-    match page_result {
-        Ok(Ok(html)) => Ok(html),
-        Ok(Err(e)) => Err(e),
-        Err(_) => Err("Page load timed out after 60 seconds".to_string()),
-    }
-}
-
 /// Recursively copy a directory and its contents
 pub(crate) fn copy_dir_recursive(src: &Path, dst: &Path) -> std::io::Result<()> {
     fs::create_dir_all(dst)?;

src/tools/browser/session.rs

@@ -398,13 +398,13 @@ impl BrowserSessionManager {
 // =============================================================================
 
 /// Extracted page content
-struct PageContent {
-    title: Option<String>,
-    markdown: String,
+pub(crate) struct PageContent {
+    pub(crate) title: Option<String>,
+    pub(crate) markdown: String,
 }
 
 /// Launch a new browser instance and navigate to the given URL.
-async fn launch_browser(
+pub(crate) async fn launch_browser(
     url: &str,
 ) -> Result<(Browser, Page, JoinHandle<()>, Option<std::path::PathBuf>), String> {
     let ctx = browser_context().cloned().unwrap_or_default();
@@ -596,7 +596,7 @@ async fn get_current_url(page: &Page) -> Option<String> {
 }
 
 /// Extract readable content from the current page.
-async fn extract_page_content(page: &Page, url: &str) -> Result<PageContent, String> {
+pub(crate) async fn extract_page_content(page: &Page, url: &str) -> Result<PageContent, String> {
     let html = page
         .content()
         .await