Merge pull request GCWing#685 from wgqqqqq/codex/flashgrep-log-isolation

chore(search): isolate flashgrep logs and bump bundle v0.2.7

Author: wgqqqqq

resources/flashgrep/VERSION.json

@@ -1,5 +1,5 @@
 {
   "repo": "wgqqqqq/flashgrep",
-  "tag": "v0.2.6",
-  "published_at": "2026-05-11T06:49:11Z"
+  "tag": "v0.2.7",
+  "published_at": "2026-05-12T04:48:18Z"
 }

resources/flashgrep/flashgrep-aarch64-apple-darwin

@@ -14,6 +14,7 @@ use tauri_plugin_log::{fern, RotationStrategy, Target, TargetKind, TimezoneStrat
 
 const SESSION_DIR_PATTERN: &str = r"^\d{8}T\d{6}$";
 const MAX_LOG_SESSIONS: usize = 10;
+const FLASHGREP_LOG_TARGET_PREFIX: &str = "flashgrep";
 static SESSION_LOG_DIR: OnceLock<PathBuf> = OnceLock::new();
 // Default to Debug in early development for easier diagnostics
 static CURRENT_LOG_LEVEL: AtomicU8 = AtomicU8::new(level_filter_to_u8(log::LevelFilter::Debug));
@@ -157,6 +158,7 @@ pub struct RuntimeLoggingInfo {
     pub session_log_dir: String,
     pub app_log_path: String,
     pub ai_log_path: String,
+    pub flashgrep_log_path: String,
     pub webview_log_path: String,
 }
 
@@ -169,13 +171,21 @@ pub fn get_runtime_logging_info() -> RuntimeLoggingInfo {
         session_log_dir: session_dir.to_string_lossy().to_string(),
         app_log_path: session_dir.join("app.log").to_string_lossy().to_string(),
         ai_log_path: session_dir.join("ai.log").to_string_lossy().to_string(),
+        flashgrep_log_path: session_dir
+            .join("flashgrep.log")
+            .to_string_lossy()
+            .to_string(),
         webview_log_path: session_dir
             .join("webview.log")
             .to_string_lossy()
             .to_string(),
     }
 }
 
+fn is_flashgrep_target(target: &str) -> bool {
+    target.starts_with(FLASHGREP_LOG_TARGET_PREFIX)
+}
+
 pub fn create_session_log_dir() -> PathBuf {
     let logs_root = resolve_logs_root();
 
@@ -205,7 +215,9 @@ pub fn build_log_targets(config: &LogConfig) -> Vec<Target> {
             Target::new(TargetKind::Stdout)
                 .filter(|metadata| {
                     let target = metadata.target();
-                    !target.starts_with("ai") && !target.starts_with("webview")
+                    !target.starts_with("ai")
+                        && !target.starts_with("webview")
+                        && !is_flashgrep_target(target)
                 })
                 .format(|out, message, record| {
                     let target = record.target();
@@ -246,7 +258,9 @@ pub fn build_log_targets(config: &LogConfig) -> Vec<Target> {
             })
             .filter(|metadata| {
                 let target = metadata.target();
-                !target.starts_with("ai") && !target.starts_with("webview")
+                !target.starts_with("ai")
+                    && !target.starts_with("webview")
+                    && !is_flashgrep_target(target)
             })
             .format(format_log_plain),
         );
@@ -261,6 +275,16 @@ pub fn build_log_targets(config: &LogConfig) -> Vec<Target> {
             .format(format_log_plain),
         );
 
+        let flashgrep_log_dir = session_dir.clone();
+        targets.push(
+            Target::new(TargetKind::Folder {
+                path: flashgrep_log_dir,
+                file_name: Some("flashgrep".into()),
+            })
+            .filter(|metadata| is_flashgrep_target(metadata.target()))
+            .format(format_log_plain),
+        );
+
         let webview_log_dir = session_dir;
         targets.push(
             Target::new(TargetKind::Folder {
@@ -289,6 +313,7 @@ pub fn build_log_plugin<R: Runtime>(log_targets: Vec<Target>) -> TauriPlugin<R>
         .level_for("h2", log::LevelFilter::Info)
         .level_for("portable_pty", log::LevelFilter::Info)
         .level_for("russh", log::LevelFilter::Info)
+        .level_for("grep_searcher", log::LevelFilter::Warn)
         .targets(log_targets)
         .rotation_strategy(RotationStrategy::KeepSome(2)) // 1 active + 2 backups
         .max_file_size(10 * 1024 * 1024)

resources/flashgrep/flashgrep-aarch64-pc-windows-msvc.exe

@@ -19,6 +19,7 @@ use tokio::{
 
 use super::{
     error::{AppError, Result},
+    log_flashgrep_stderr_line, FLASHGREP_LOG_TARGET,
     protocol::{
         ClientCapabilities, ClientInfo, GlobParams, InitializeParams, RepoRef, Request, Response,
         SearchParams, TaskRef,
@@ -169,6 +170,7 @@ impl ManagedClient {
                 self.clear_daemon_if_current(&daemon).await;
                 if let Err(shutdown_error) = daemon.shutdown().await {
                     log::debug!(
+                        target: FLASHGREP_LOG_TARGET,
                         "Flashgrep stdio daemon shutdown after transport error failed: {}",
                         shutdown_error
                     );
@@ -469,6 +471,7 @@ impl AsyncDaemonClient {
                 .await;
             if let Err(terminate_error) = client.wait_for_child_exit().await {
                 log::debug!(
+                    target: FLASHGREP_LOG_TARGET,
                     "Flashgrep stdio daemon cleanup after failed startup errored: {}",
                     terminate_error
                 );
@@ -584,14 +587,22 @@ impl AsyncDaemonClient {
             let mut writer = BufWriter::new(stdin);
             while let Some(outbound) = write_rx.recv().await {
                 if let Err(error) = writer.write_all(&outbound).await {
-                    log::debug!("flashgrep stdio daemon stdin write failed: {}", error);
+                    log::debug!(
+                        target: FLASHGREP_LOG_TARGET,
+                        "flashgrep stdio daemon stdin write failed: {}",
+                        error
+                    );
                     protocol
                         .close_with_message("flashgrep stdio backend stdin write failed")
                         .await;
                     return;
                 }
                 if let Err(error) = writer.flush().await {
-                    log::debug!("flashgrep stdio daemon stdin flush failed: {}", error);
+                    log::debug!(
+                        target: FLASHGREP_LOG_TARGET,
+                        "flashgrep stdio daemon stdin flush failed: {}",
+                        error
+                    );
                     protocol
                         .close_with_message("flashgrep stdio backend stdin flush failed")
                         .await;
@@ -639,9 +650,13 @@ impl AsyncDaemonClient {
                 line.clear();
                 match reader.read_line(&mut line).await {
                     Ok(0) => break,
-                    Ok(_) => log::debug!("flashgrep stdio daemon stderr: {}", line.trim_end()),
+                    Ok(_) => log_flashgrep_stderr_line(&line),
                     Err(error) => {
-                        log::debug!("flashgrep stdio daemon stderr read failed: {}", error);
+                        log::debug!(
+                            target: FLASHGREP_LOG_TARGET,
+                            "flashgrep stdio daemon stderr read failed: {}",
+                            error
+                        );
                         break;
                     }
                 }

resources/flashgrep/flashgrep-aarch64-unknown-linux-musl

@@ -5,6 +5,44 @@ mod repo_session;
 mod rpc_client;
 mod types;
 
+pub(crate) const FLASHGREP_LOG_TARGET: &str = "flashgrep";
+
+pub(crate) fn log_flashgrep_stderr_line(line: &str) {
+    log_flashgrep_stderr_line_with_context(None, line);
+}
+
+pub(crate) fn log_flashgrep_stderr_line_with_context(context: Option<&str>, line: &str) {
+    let trimmed = line.trim();
+    if trimmed.is_empty() {
+        return;
+    }
+
+    if let Some(rest) = trimmed.strip_prefix("flashgrep[") {
+        if let Some((area, rest)) = rest.split_once("][") {
+            if let Some((level, message)) = rest.split_once("] ") {
+                let formatted = match context {
+                    Some(context) => format!("flashgrep[{area}] {context} {message}"),
+                    None => format!("flashgrep[{area}] {message}"),
+                };
+                match level {
+                    "error" => log::error!(target: FLASHGREP_LOG_TARGET, "{formatted}"),
+                    "warn" => log::warn!(target: FLASHGREP_LOG_TARGET, "{formatted}"),
+                    "info" => log::info!(target: FLASHGREP_LOG_TARGET, "{formatted}"),
+                    "debug" => log::debug!(target: FLASHGREP_LOG_TARGET, "{formatted}"),
+                    "trace" => log::trace!(target: FLASHGREP_LOG_TARGET, "{formatted}"),
+                    _ => log::debug!(target: FLASHGREP_LOG_TARGET, "{trimmed}"),
+                }
+                return;
+            }
+        }
+    }
+
+    match context {
+        Some(context) => log::debug!(target: FLASHGREP_LOG_TARGET, "{context} {trimmed}"),
+        None => log::debug!(target: FLASHGREP_LOG_TARGET, "{trimmed}"),
+    }
+}
+
 pub(crate) use client::{ManagedClient, RepoSession};
 pub(crate) use protocol::{
     ClientCapabilities, ClientInfo, FileMatch, GlobParams, InitializeParams, MatchLocation,