mason: use recorded dashboard project identities

Author: ualtinok

packages/dashboard/src-tauri/Cargo.lock

@@ -25,7 +25,6 @@ lazy_static = "1"
 tokio = { version = "1", features = ["fs", "io-util", "sync", "macros", "process", "time", "rt-multi-thread", "net"] }
 reqwest = { version = "0.12", features = ["json"] }
 md5 = "0.7"
-wait-timeout = "0.2"
 tauri-plugin-updater = "2"
 tauri-plugin-process = "2"
 tauri-plugin-dialog = "2"

packages/dashboard/src-tauri/Cargo.toml

@@ -22,6 +22,7 @@ pub fn get_projects(state: State<'_, AppState>) -> Result<Vec<db::ProjectInfo>,
 }
 
 #[tauri::command(async)]
+#[allow(clippy::too_many_arguments)]
 pub fn get_memories(
     state: State<'_, AppState>,
     project: Option<String>,
@@ -1117,6 +1118,7 @@ pub async fn get_available_pi_models() -> Vec<String> {
 ///
 /// 3. 401/403 → `AuthFailed` (specific "credentials rejected" message).
 ///    404/405 → `EndpointUnsupported` (wrong URL / no embeddings API).
+///
 /// Expand an `{env:}`/`{file:}` token in one probe field, mapping a failure to
 /// the matching probe outcome. The embedding fields come from the USER-level
 /// config editor, so expanding the user's own tokens to test their endpoint is

packages/dashboard/src-tauri/src/commands.rs

@@ -106,7 +106,7 @@ pub fn read_config(path: &PathBuf, source: &str) -> ConfigFile {
     }
 }
 
-pub fn write_config(path: &PathBuf, content: &str) -> Result<(), String> {
+pub fn write_config(path: &Path, content: &str) -> Result<(), String> {
     write_config_atomic(path, content, None)
 }
 

packages/dashboard/src-tauri/src/config.rs

@@ -498,7 +498,7 @@ fn is_cloud_metadata_ip(ip: IpAddr) -> bool {
             v6 == Ipv6Addr::new(0xfd00, 0x0ec2, 0, 0, 0, 0, 0, 0x254)
                 || v6
                     .to_ipv4_mapped()
-                    .map_or(false, |m| m.octets() == [169, 254, 169, 254])
+                    .is_some_and(|m| m.octets() == [169, 254, 169, 254])
         }
     }
 }

packages/dashboard/src-tauri/src/db.rs

@@ -1,8 +1,7 @@
 //! Cross-platform helper to suppress the console window that Windows spawns for
-//! every child process. The dashboard shells out to `git` (once per project when
-//! resolving identities), `opencode`, and `pi`; without `CREATE_NO_WINDOW` each
-//! spawn flashes a console window, so opening the dashboard on Windows can pop a
-//! dozen-plus terminals (issue #115).
+//! every child process. The dashboard shells out to external tools such as
+//! `opencode` and `pi`; without `CREATE_NO_WINDOW` each spawn flashes a console
+//! window, so opening the dashboard on Windows can pop a dozen-plus terminals.
 //!
 //! On non-Windows targets these are no-ops, so call sites stay uniform.
 

packages/dashboard/src-tauri/src/embedding_probe.rs

@@ -1,27 +1,4 @@
-use std::collections::HashMap;
 use std::path::{Component, Path, PathBuf};
-use std::process::{Command, Stdio};
-
-use crate::process_ext::NoWindowExt;
-use std::sync::{OnceLock, RwLock};
-use std::time::Duration;
-
-use wait_timeout::ChildExt;
-
-const GIT_TIMEOUT: Duration = Duration::from_secs(5);
-
-static IDENTITY_CACHE: OnceLock<RwLock<HashMap<PathBuf, String>>> = OnceLock::new();
-
-fn cache() -> &'static RwLock<HashMap<PathBuf, String>> {
-    IDENTITY_CACHE.get_or_init(|| RwLock::new(HashMap::new()))
-}
-
-/// Whether a `.git` exists at `canonical` (worktree dir or a gitdir file/dir).
-/// Used to invalidate a cached `dir:` fallback once a repo appears — mirrors the
-/// TS resolver's `hasGitDir` re-resolve gate.
-fn has_git_dir(canonical: &Path) -> bool {
-    canonical.join(".git").exists()
-}
 
 /// Lexically resolve `input` against `cwd`, matching Node's `path.resolve` semantics.
 ///
@@ -72,174 +49,6 @@ pub fn logical_absolute(input: &Path, cwd: &Path) -> PathBuf {
     base
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum IdentityErrorClass {
-    NotGitRepo,
-    /// The directory does not exist / is not reachable. Deterministic: the same
-    /// missing path always yields the same `dir:` fallback, so it is safe to
-    /// cache (mirrors the TS "Unable to access project directory" fallback).
-    PathInaccessible,
-    GitMissing,
-    GitTimeout,
-    PermissionDenied,
-    Unknown,
-}
-
-impl IdentityErrorClass {
-    /// Whether this failure is DETERMINISTIC (same input always reproduces it),
-    /// so a `dir:` fallback may be cached. Transient classes (git binary
-    /// missing, timeout, permission, unknown spawn/wait failures) must NOT be
-    /// cached — a retry could resolve the real `git:` identity. This mirrors the
-    /// TS resolver, which only falls back for `not_git_repo` + inaccessible-path
-    /// and never caches transient failures.
-    fn is_deterministic_fallback(self) -> bool {
-        matches!(
-            self,
-            IdentityErrorClass::NotGitRepo | IdentityErrorClass::PathInaccessible
-        )
-    }
-}
-
-pub fn resolve_project_identity_strict(directory: &Path) -> Result<String, IdentityErrorClass> {
-    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-    let canonical = logical_absolute(directory, &cwd);
-
-    // If the cwd itself is missing, the git spawn would also return NotFound; distinguish
-    // that from a missing git binary before classifying the spawn error. Use
-    // metadata() (not exists(), which collapses ALL errors to false): a genuine
-    // NotFound is DETERMINISTIC (cacheable dir: fallback), but a PermissionDenied/
-    // other stat error is TRANSIENT and must NOT be cached (a retry could resolve
-    // the real git: identity once access is restored).
-    match std::fs::metadata(&canonical) {
-        Ok(_) => {}
-        Err(error) => {
-            return Err(match error.kind() {
-                std::io::ErrorKind::NotFound => IdentityErrorClass::PathInaccessible,
-                std::io::ErrorKind::PermissionDenied => IdentityErrorClass::PermissionDenied,
-                _ => IdentityErrorClass::Unknown,
-            });
-        }
-    }
-
-    let mut child = Command::new("git")
-        .args(["rev-list", "--max-parents=0", "HEAD"])
-        .current_dir(&canonical)
-        .env("LC_ALL", "C")
-        .env("LANG", "C")
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .no_window()
-        .spawn()
-        .map_err(|error| match error.kind() {
-            std::io::ErrorKind::NotFound => IdentityErrorClass::GitMissing,
-            std::io::ErrorKind::PermissionDenied => IdentityErrorClass::PermissionDenied,
-            _ => IdentityErrorClass::Unknown,
-        })?;
-
-    let status = match child
-        .wait_timeout(GIT_TIMEOUT)
-        .map_err(|_| IdentityErrorClass::Unknown)?
-    {
-        Some(status) => status,
-        None => {
-            let _ = child.kill();
-            let _ = child.wait();
-            return Err(IdentityErrorClass::GitTimeout);
-        }
-    };
-
-    let output = child
-        .wait_with_output()
-        .map_err(|_| IdentityErrorClass::Unknown)?;
-
-    if status.success() {
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let first_line = stdout.lines().next().unwrap_or("").trim();
-        if first_line.len() < 7 {
-            return Err(IdentityErrorClass::Unknown);
-        }
-        // TS accepts the complete root hash line. SHA-1 repos produce 40 chars;
-        // SHA-256 repos produce 64. Cap at 64 to avoid accepting accidental noise.
-        let sha = first_line.chars().take(64).collect::<String>();
-        return Ok(format!("git:{sha}"));
-    }
-
-    let stderr = String::from_utf8_lossy(&output.stderr).to_ascii_lowercase();
-    if stderr.contains("not a git repository") {
-        Err(IdentityErrorClass::NotGitRepo)
-    } else if stderr.contains("permission denied") {
-        Err(IdentityErrorClass::PermissionDenied)
-    } else {
-        Err(IdentityErrorClass::Unknown)
-    }
-}
-
-/// Resolve a raw filesystem path to the stable project identity used by the TS plugin.
-///
-/// Mirrors `packages/plugin/src/features/magic-context/memory/project-identity.ts`:
-/// logical absolute path resolution, `git rev-list --max-parents=0 HEAD`, and
-/// `dir:<md5-12>` fallback over the resolved UTF-8 path bytes.
-pub fn resolve_project_identity<P: AsRef<Path>>(directory: P) -> String {
-    let directory = directory.as_ref();
-    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-    let canonical = logical_absolute(directory, &cwd);
-
-    if let Ok(cache) = cache().read() {
-        if let Some(identity) = cache.get(&canonical) {
-            // Serve a cached `git:` identity directly (stable once a repo exists).
-            // A cached `dir:` FALLBACK, however, must be dropped the moment a `.git`
-            // appears, so the identity can flip to the stable `git:<root>` — the
-            // common "scratch dir later `git init` + first commit" case. Without
-            // this re-resolve gate the dashboard pins the wrong `dir:` identity for
-            // the whole process and mis-groups the project (P0: it then reads/
-            // mutates the wrong project's memories). Mirrors TS resolveProjectIdentity.
-            if identity.starts_with("git:") || !has_git_dir(&canonical) {
-                return identity.clone();
-            }
-        }
-    }
-    // Cached fallback is stale (a repo appeared) — evict before re-resolving.
-    if let Ok(mut cache) = cache().write() {
-        if let Some(identity) = cache.get(&canonical) {
-            if identity.starts_with("dir:") && has_git_dir(&canonical) {
-                cache.remove(&canonical);
-            }
-        }
-    }
-
-    match resolve_project_identity_strict(&canonical) {
-        Ok(identity) => {
-            if let Ok(mut cache) = cache().write() {
-                cache.insert(canonical, identity.clone());
-            }
-            identity
-        }
-        Err(error) => {
-            let fallback = directory_fallback(&canonical);
-            // Only cache the fallback for DETERMINISTIC failures (not-git /
-            // inaccessible path). Transient failures (git missing/timeout/
-            // permission/unknown) return the fallback UNCACHED so a later call
-            // can still resolve the real `git:` identity once the transient
-            // condition clears — caching here would pin a wrong `dir:` identity
-            // for the whole process and mis-group the project in the UI. This
-            // matches the TS resolver's fallback/propagation policy (the
-            // dashboard degrades to a fallback instead of throwing because it is
-            // a read-only viewer that must still render something).
-            if error.is_deterministic_fallback() {
-                if let Ok(mut cache) = cache().write() {
-                    cache.insert(canonical, fallback.clone());
-                }
-            } else {
-                eprintln!(
-                    "[dashboard] resolve_project_identity transient error {:?} on {:?} (uncached fallback)",
-                    error, canonical
-                );
-            }
-            fallback
-        }
-    }
-}
-
 fn directory_fallback(path: &Path) -> String {
     let digest = md5::compute(path.to_string_lossy().as_bytes());
     let hex = format!("{digest:x}");
@@ -249,13 +58,16 @@ fn directory_fallback(path: &Path) -> String {
 /// Normalize a value read from `memories.project_path` / related stored identity columns.
 ///
 /// Stored DB values may already be identities (`git:*`, `dir:*`). Those must be returned
-/// unchanged; passing them through `resolve_project_identity` would hash the identity text as
-/// a filesystem path and corrupt the project_state key.
+/// unchanged; hashing the identity text as a filesystem path would produce a wrong project
+/// key. Legacy raw paths degrade to the deterministic directory fallback so the dashboard
+/// never probes git while reading historical rows.
 pub fn normalize_stored_project_path(raw_or_stored: &str) -> String {
     if raw_or_stored.starts_with("git:") || raw_or_stored.starts_with("dir:") {
         return raw_or_stored.to_string();
     }
-    resolve_project_identity(Path::new(raw_or_stored))
+    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    let canonical = logical_absolute(Path::new(raw_or_stored), &cwd);
+    directory_fallback(&canonical)
 }
 
 pub fn basename(path: &str) -> String {
@@ -266,56 +78,45 @@ pub fn basename(path: &str) -> String {
         .unwrap_or_else(|| path.to_string())
 }
 
-#[doc(hidden)]
-pub fn clear_cache_for_tests() {
-    if let Ok(mut cache) = cache().write() {
-        cache.clear();
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    fn expected_dir_identity(path: &Path) -> String {
+        let digest = md5::compute(path.to_string_lossy().as_bytes());
+        let hex = format!("{digest:x}");
+        format!("dir:{}", &hex[..12])
+    }
+
     #[test]
-    fn resolves_current_repo_as_git_identity() {
-        clear_cache_for_tests();
-        let identity = resolve_project_identity(".");
-        assert!(identity.starts_with("git:"), "{identity}");
-        assert!(identity.len() > 11);
+    fn normalize_stored_project_path_preserves_identity_values() {
+        assert_eq!(normalize_stored_project_path("git:abc123"), "git:abc123");
+        assert_eq!(
+            normalize_stored_project_path("dir:deadbeef0000"),
+            "dir:deadbeef0000"
+        );
     }
 
     #[test]
-    fn non_git_directory_uses_md5_dir_identity() {
-        clear_cache_for_tests();
+    fn normalize_stored_project_path_hashes_raw_paths_without_git() {
         let dir = tempfile::tempdir().unwrap();
-        let identity = resolve_project_identity(dir.path());
-        assert!(identity.starts_with("dir:"), "{identity}");
-        assert_eq!(identity.len(), 16);
+        let identity = normalize_stored_project_path(dir.path().to_str().unwrap());
+        assert_eq!(identity, expected_dir_identity(dir.path()));
     }
 
     #[test]
-    fn only_deterministic_failures_are_cacheable() {
-        // Mirrors the TS resolver: not-git and inaccessible-path are
-        // deterministic (cacheable `dir:` fallback); transient failures
-        // (git missing/timeout/permission/unknown) must NOT be cached so a
-        // retry can still resolve the real `git:` identity.
-        assert!(IdentityErrorClass::NotGitRepo.is_deterministic_fallback());
-        assert!(IdentityErrorClass::PathInaccessible.is_deterministic_fallback());
-        assert!(!IdentityErrorClass::GitMissing.is_deterministic_fallback());
-        assert!(!IdentityErrorClass::GitTimeout.is_deterministic_fallback());
-        assert!(!IdentityErrorClass::PermissionDenied.is_deterministic_fallback());
-        assert!(!IdentityErrorClass::Unknown.is_deterministic_fallback());
+    fn relative_raw_paths_are_resolved_logically_before_hashing() {
+        let cwd = std::env::current_dir().unwrap();
+        let resolved = logical_absolute(Path::new("relative/project"), &cwd);
+        assert_eq!(
+            normalize_stored_project_path("relative/project"),
+            expected_dir_identity(&resolved)
+        );
     }
 
     #[test]
-    fn inaccessible_path_classifies_deterministically() {
-        let missing = std::env::temp_dir().join("mc-nonexistent-проект-xyz-987654321");
-        let err = resolve_project_identity_strict(&missing).unwrap_err();
-        assert_eq!(err, IdentityErrorClass::PathInaccessible);
-        // Deterministic → resolve_project_identity returns a cached dir: fallback.
-        clear_cache_for_tests();
-        let identity = resolve_project_identity(&missing);
-        assert!(identity.starts_with("dir:"), "{identity}");
+    fn basename_uses_last_path_component_when_present() {
+        assert_eq!(basename("/tmp/example"), "example");
+        assert_eq!(basename("/"), "/");
     }
 }