use codex_windows_sandbox::log_note;use std::collections::hash_map::DefaultHasher;use std::hash::Hash;use std::hash::Hasher;use std::os::windows::fs::MetadataExt as _;use std::os::windows::process::CommandExt as _;use std::path::Path;use std::path::PathBuf;use windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_REPARSE_POINT;fn junction_name_for_path(path: &Path) -> String {    let mut hasher = DefaultHasher::new();    path.to_string_lossy().hash(&mut hasher);    format!("{:x}", hasher.finish())}fn junction_root_for_userprofile(userprofile: &str) -> PathBuf {    PathBuf::from(userprofile)        .join(".codex")        .join(".sandbox")        .join("cwd")}pub fn create_cwd_junction(requested_cwd: &Path, log_dir: Option<&Path>) -> Option<PathBuf> {    let userprofile = std::env::var("USERPROFILE").ok()?;    let junction_root = junction_root_for_userprofile(&userprofile);    if let Err(err) = std::fs::create_dir_all(&junction_root) {        log_note(            &format!(                "junction: failed to create {}: {err}",                junction_root.display()            ),            log_dir,        );        return None;    }    let junction_path = junction_root.join(junction_name_for_path(requested_cwd));    if junction_path.exists() {        // Reuse an existing junction if it looks like a reparse point; this keeps the hot path        // cheap and avoids repeatedly shelling out to mklink.        match std::fs::symlink_metadata(&junction_path) {            Ok(md) if (md.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT) != 0 => {                log_note(                    &format!("junction: reusing existing {}", junction_path.display()),                    log_dir,                );                return Some(junction_path);            }            Ok(_) => {                // Unexpected: something else exists at this path (regular directory/file). We'll                // try to remove it if possible and recreate the junction.                log_note(                    &format!(                        "junction: existing path is not a reparse point, recreating {}",                        junction_path.display()                    ),                    log_dir,                );            }            Err(err) => {                log_note(                    &format!(                        "junction: failed to stat existing {}: {err}",                        junction_path.display()                    ),                    log_dir,                );                return None;            }        }        if let Err(err) = std::fs::remove_dir(&junction_path) {            log_note(                &format!(                    "junction: failed to remove existing {}: {err}",                    junction_path.display()                ),                log_dir,            );            return None;        }    }    let link = junction_path.to_string_lossy().to_string();    let target = requested_cwd.to_string_lossy().to_string();    // Use `cmd /c` so we can call `mklink` (a cmd builtin). We must quote paths so CWDs    // containing spaces work reliably.    //    // IMPORTANT: `std::process::Command::args()` will apply Windows quoting/escaping rules when    // constructing the command line. Passing a single argument that itself contains quotes can    // confuse `cmd.exe` and cause mklink to fail with "syntax is incorrect". We avoid that by    // using `raw_arg` to pass the tokens exactly as `cmd.exe` expects to parse them.    //    // Paths cannot contain quotes on Windows, so no extra escaping is needed here.    let link_quoted = format!("\"{link}\"");    let target_quoted = format!("\"{target}\"");    log_note(        &format!("junction: creating via cmd /c mklink /J {link_quoted} {target_quoted}"),        log_dir,    );    let output = match std::process::Command::new("cmd")        .raw_arg("/c")        .raw_arg("mklink")        .raw_arg("/J")        .raw_arg(&link_quoted)        .raw_arg(&target_quoted)        .output()    {        Ok(output) => output,        Err(err) => {            log_note(&format!("junction: mklink failed to run: {err}"), log_dir);            return None;        }    };    if output.status.success() && junction_path.exists() {        log_note(            &format!(                "junction: created {} -> {}",                junction_path.display(),                requested_cwd.display()            ),            log_dir,        );        return Some(junction_path);    }    let stdout = String::from_utf8_lossy(&output.stdout);    let stderr = String::from_utf8_lossy(&output.stderr);    log_note(        &format!(            "junction: mklink failed status={:?} stdout={} stderr={}",            output.status,            stdout.trim(),            stderr.trim()        ),        log_dir,    );    None}