`68a6e58`

perf: suppress file-watcher events for pty-owned sessions + 2s debounce

Authored by

espadonne 1 month ago

SHA: 68a6e580aaaae26ed8b0adf8e58001a3da5789ec
Parents: 6b46cf2
Tree: 202f435

2 changed files

Status	File	+	-
M	`src-tauri/src/commands.rs`	50	6
M	`src/lib/store/sessions.ts`	9	1

src-tauri/src/commands.rsmodified

+     }
      let active_turns = Arc::new(DashMap::new());
 -    let active_ptys = Arc::new(DashMap::new());
 +    let active_ptys: Arc<DashMap<String, PtyEntry>> = Arc::new(DashMap::new());
      // Start the watcher, even if projects_root doesn't exist yet —
      // `spawn_watcher` errors in that case so we handle it.
          let (handle, mut rx) = spawn_watcher(&projects_root)?;
          let app_clone = app.clone();
          let cache_clone = cache.clone();
 +        let ptys_clone = active_ptys.clone();
          tauri::async_runtime::spawn(async move {
              while let Some(change) = rx.recv().await {
 -                handle_change(&app_clone, &cache_clone, change);
 +                handle_change(&app_clone, &cache_clone, &ptys_clone, change);
+             }
          });
          handle
          let (handle, mut rx) = spawn_watcher(&fallback_root)?;
          let app_clone = app.clone();
          let cache_clone = cache.clone();
 +        let ptys_clone = active_ptys.clone();
          tauri::async_runtime::spawn(async move {
              while let Some(change) = rx.recv().await {
 -                handle_change(&app_clone, &cache_clone, change);
 +                handle_change(&app_clone, &cache_clone, &ptys_clone, change);
+             }
          });
          handle
      })
+ }
 -fn handle_change(app: &AppHandle, cache: &SummaryCache, change: SessionChange) {
 +fn handle_change(
 +    app: &AppHandle,
 +    cache: &SummaryCache,
 +    active_ptys: &Arc<DashMap<String, PtyEntry>>,
 +    change: SessionChange,
 +) {
 +    // When a PTY is actively writing to this session's JSONL file,
 +    // we'd otherwise re-enter the rescan → list_projects →
 +    // summarize → sidebar re-render cycle every few hundred ms for
 +    // the duration of the subprocess's run. The PTY is already the
 +    // canonical writer and the user sees it via the xterm view, so
 +    // there's nothing new for the sidebar to learn. Skip the event
 +    // entirely for PTY-owned sessions to cut the write-storm at the
 +    // source. Cache invalidation still runs so non-PTY callers
 +    // (e.g. a manual rescan) see fresh data.
 +    let skip_emit = path_matches_live_pty(&change, active_ptys);
      match &change {
          SessionChange::Removed(path) => cache.remove(path),
          SessionChange::Added(path) | SessionChange::Modified(path) => {
              cache.remove(path);
+         }
+     }
 -    // Tell the webview something changed. v0 frontend responds with
 -    // a `rescan` invocation.
 +    if skip_emit {
 +        return;
 +    }
 +    // Tell the webview something changed. The frontend debounces
 +    // and responds with a `rescan` invocation.
      let payload = ChangePayload::from(&change);
      if let Err(e) = app.emit("sessions:changed", payload) {
          tracing::warn!(error = %e, "failed to emit sessions:changed");
+     }
+ }
 +/// Return true if the file path carrying this change is the JSONL
 +/// transcript of a session currently being driven by a live PTY.
 +/// Used by `handle_change` to suppress file-watcher events for
 +/// actively-written sessions so they don't thrash the sidebar.
 +fn path_matches_live_pty(
 +    change: &SessionChange,
 +    active_ptys: &Arc<DashMap<String, PtyEntry>>,
 +) -> bool {
 +    let path = match change {
 +        SessionChange::Added(p)
 +        | SessionChange::Modified(p)
 +        | SessionChange::Removed(p) => p,
 +    };
 +    let Some(stem) = path.file_stem().and_then(|s| s.to_str()) else {
 +        return false;
 +    };
 +    for entry in active_ptys.iter() {
 +        if entry.session_id.as_deref() == Some(stem) {
 +            return true;
 +        }
 +    }
 +    false
 +}
++
  #[derive(Debug, Clone, serde::Serialize)]
  #[serde(tag = "kind", rename_all = "snake_case")]
  enum ChangePayload {

src/lib/store/sessions.tsmodified

      if (watcherAttached) return;
      watcherAttached = true;
      await onSessionsChanged(() => {
 +      // 2s debounce is a compromise between feeling responsive when
 +      // the user finishes a claude turn in the real CLI outside
 +      // claudex (so we eventually pick up the new session on disk)
 +      // and avoiding a rescan storm while PTYs are actively
 +      // writing. The Rust side also suppresses file-watcher events
 +      // for sessions owned by a live PTY, so this mostly fires for
 +      // out-of-band changes (external claude runs, git operations,
 +      // archive pruning).
        if (pendingRescan) clearTimeout(pendingRescan);
        pendingRescan = setTimeout(() => {
          pendingRescan = null;
          void get().rescan();
 -      }, 500);
 +      }, 2000);
      });
    },