dsh-ops 0.0.0-stage → 0.2.1

package/vendor/fastctx/src/shell/bash.rs

@@ -0,0 +1,263 @@
+// Modified by dsh-ops (https://github.com/T-Auto/dsh-ops): removed probe_bash, whose only caller was the deleted control/apply.rs preflight.
+//! Deterministic bash discovery with explicit-override semantics.
+
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::OnceLock;
+
+const WINDOWS_MISSING_BASH: &str = "Cannot find a usable bash. fastshell runs every command with bash for consistent cross-platform behavior. Install Git for Windows (https://git-scm.com/downloads) or set FASTCTX_BASH to the absolute path of bash.exe. Note: C:/Windows/System32/bash.exe is the WSL launcher, not a standalone bash.";
+const UNIX_MISSING_BASH: &str =
+    "Cannot find a usable bash. Install bash or set FASTCTX_BASH to its absolute path.";
+
+/// Caches the validated backend for one MCP connection.
+#[derive(Debug, Default)]
+pub(crate) struct BashLocator {
+    cached: OnceLock<Result<PathBuf, String>>,
+    locale: OnceLock<String>,
+}
+
+impl BashLocator {
+    /// Returns the validated bash path, probing at most once per connection.
+    pub(crate) fn resolve(
+        &self,
+        environment: &crate::session::SessionEnvironment,
+    ) -> Result<PathBuf, String> {
+        self.cached
+            .get_or_init(|| probe_bash_with_environment(environment))
+            .clone()
+    }
+
+    /// Returns a locale probed once for this connection's bash and environment.
+    pub(crate) fn utf8_locale<'a>(
+        &'a self,
+        environment: &crate::session::SessionEnvironment,
+        bash: &Path,
+    ) -> &'a str {
+        self.locale
+            .get_or_init(|| crate::shell::process::detect_utf8_locale(bash, environment))
+            .as_str()
+    }
+}
+
+fn probe_bash_with_environment(
+    environment: &crate::session::SessionEnvironment,
+) -> Result<PathBuf, String> {
+    match environment.var("FASTCTX_BASH") {
+        Ok(value) => return validate_override_with_environment(&value, environment),
+        Err(std::env::VarError::NotUnicode(_)) => {
+            return Err("Invalid FASTCTX_BASH value \"<non-UTF-8>\": not a working bash (the path is not valid UTF-8). Fix or unset it.".to_string());
+        }
+        Err(std::env::VarError::NotPresent) => {}
+    }
+
+    let mut seen = HashSet::new();
+    for candidate in automatic_candidates(environment) {
+        if excluded_candidate(&candidate, environment) || !seen.insert(candidate_key(&candidate)) {
+            continue;
+        }
+        if validate_bash(&candidate, environment).is_ok() {
+            return Ok(candidate);
+        }
+    }
+    Err(missing_bash_message().to_string())
+}
+
+#[cfg(test)]
+fn validate_override(value: &str) -> Result<PathBuf, String> {
+    let environment = crate::session::SessionEnvironment::capture()?;
+    validate_override_with_environment(value, &environment)
+}
+
+fn validate_override_with_environment(
+    value: &str,
+    environment: &crate::session::SessionEnvironment,
+) -> Result<PathBuf, String> {
+    let path = crate::paths::parse_input_path(value);
+    let result = if !path.is_absolute() {
+        Err("the path is not absolute".to_string())
+    } else if excluded_candidate(&path, environment) {
+        Err("the path points to the Windows/WSL launcher or a WindowsApps shim".to_string())
+    } else {
+        validate_bash(&path, environment)
+    };
+    result.map(|_| path).map_err(|reason| {
+        format!(
+            "Invalid FASTCTX_BASH value \"{value}\": not a working bash ({reason}). Fix or unset it."
+        )
+    })
+}
+
+fn validate_bash(
+    path: &Path,
+    environment: &crate::session::SessionEnvironment,
+) -> Result<(), String> {
+    if !path.is_absolute() {
+        return Err("the path is not absolute".to_string());
+    }
+    if !path.is_file() {
+        return Err("the file does not exist".to_string());
+    }
+    let mut command = crate::process_policy::noninteractive_command(path);
+    environment.configure_command(&mut command);
+    let output = command
+        .arg("--version")
+        .output()
+        .map_err(|error| error.to_string())?;
+    let mut text = String::from_utf8_lossy(&output.stdout).into_owned();
+    text.push_str(&String::from_utf8_lossy(&output.stderr));
+    if !output.status.success() {
+        return Err(format!(
+            "--version exited {}",
+            output.status.code().unwrap_or(1)
+        ));
+    }
+    if !text.contains("GNU bash") {
+        return Err("--version output did not contain GNU bash".to_string());
+    }
+    Ok(())
+}
+
+#[cfg(windows)]
+fn automatic_candidates(environment: &crate::session::SessionEnvironment) -> Vec<PathBuf> {
+    let mut candidates = Vec::new();
+    for git in path_candidates(environment, "git.exe") {
+        let mut ancestor = git.parent();
+        for _ in 0..4 {
+            let Some(directory) = ancestor else { break };
+            candidates.push(directory.join("usr").join("bin").join("bash.exe"));
+            ancestor = directory.parent();
+        }
+    }
+    for variable in ["ProgramFiles", "ProgramFiles(x86)"] {
+        if let Some(root) = environment.var_os(variable) {
+            candidates.push(PathBuf::from(root).join("Git/usr/bin/bash.exe"));
+        }
+    }
+    if let Some(root) = environment.var_os("LocalAppData") {
+        candidates.push(PathBuf::from(root).join("Programs/Git/usr/bin/bash.exe"));
+    }
+    // Scoop exposes only a shim directory on PATH, so walking up from its
+    // git.exe never reaches the Git root that carries usr/bin.
+    if let Some(root) = environment.var_os("SCOOP") {
+        candidates.push(PathBuf::from(root).join("apps/git/current/usr/bin/bash.exe"));
+    }
+    if let Some(profile) = environment.var_os("USERPROFILE") {
+        candidates.push(PathBuf::from(profile).join("scoop/apps/git/current/usr/bin/bash.exe"));
+    }
+    candidates.extend(path_candidates(environment, "bash.exe"));
+    candidates
+}
+
+#[cfg(not(windows))]
+fn automatic_candidates(environment: &crate::session::SessionEnvironment) -> Vec<PathBuf> {
+    let mut candidates = vec![PathBuf::from("/bin/bash"), PathBuf::from("/usr/bin/bash")];
+    candidates.extend(path_candidates(environment, "bash"));
+    candidates
+}
+
+fn path_candidates(environment: &crate::session::SessionEnvironment, name: &str) -> Vec<PathBuf> {
+    environment
+        .var_os("PATH")
+        .map(|path| {
+            std::env::split_paths(&path)
+                .map(|directory| directory.join(name))
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+#[cfg(windows)]
+fn excluded_candidate(path: &Path, environment: &crate::session::SessionEnvironment) -> bool {
+    let canonical = crate::paths::canonical_existing(path).unwrap_or_else(|_| path.to_path_buf());
+    let root = environment
+        .var_os("SystemRoot")
+        .map(PathBuf::from)
+        .map(|root| crate::paths::canonical_existing(&root).unwrap_or(root));
+    excluded_windows_candidate(&canonical, root.as_deref())
+}
+
+#[cfg(windows)]
+fn excluded_windows_candidate(path: &Path, system_root: Option<&Path>) -> bool {
+    let candidate = path
+        .to_string_lossy()
+        .replace('/', "\\")
+        .to_ascii_lowercase();
+    if candidate.contains("\\windowsapps\\") {
+        return true;
+    }
+    system_root
+        .map(|root| {
+            let root = root
+                .to_string_lossy()
+                .replace('/', "\\")
+                .trim_end_matches('\\')
+                .to_ascii_lowercase();
+            candidate == root || candidate.starts_with(&format!("{root}\\"))
+        })
+        .unwrap_or(false)
+}
+
+#[cfg(not(windows))]
+fn excluded_candidate(_path: &Path, _environment: &crate::session::SessionEnvironment) -> bool {
+    false
+}
+
+fn candidate_key(path: &Path) -> String {
+    let key = path.to_string_lossy().replace('\\', "/");
+    if cfg!(windows) {
+        key.to_ascii_lowercase()
+    } else {
+        key
+    }
+}
+
+fn missing_bash_message() -> &'static str {
+    if cfg!(windows) {
+        WINDOWS_MISSING_BASH
+    } else {
+        UNIX_MISSING_BASH
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{candidate_key, validate_override};
+
+    #[test]
+    fn explicit_override_rejects_relative_paths_without_fallback() {
+        let error = validate_override("relative/bash").unwrap_err();
+        assert_eq!(
+            error,
+            "Invalid FASTCTX_BASH value \"relative/bash\": not a working bash (the path is not absolute). Fix or unset it."
+        );
+    }
+
+    #[test]
+    fn candidate_keys_follow_platform_path_case_rules() {
+        let key = candidate_key(std::path::Path::new("C:\\Tools\\Bash.exe"));
+        if cfg!(windows) {
+            assert_eq!(key, "c:/tools/bash.exe");
+        } else {
+            assert_eq!(key, "C:/Tools/Bash.exe");
+        }
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn windows_exclusion_rejects_systemroot_and_windowsapps_without_path_probing() {
+        use super::excluded_windows_candidate;
+        let root = std::path::Path::new("C:/Windows");
+        assert!(excluded_windows_candidate(
+            std::path::Path::new("C:/Windows/System32/bash.exe"),
+            Some(root)
+        ));
+        assert!(excluded_windows_candidate(
+            std::path::Path::new("C:/Users/test/AppData/Local/Microsoft/WindowsApps/bash.exe"),
+            Some(root)
+        ));
+        assert!(!excluded_windows_candidate(
+            std::path::Path::new("C:/Program Files/Git/usr/bin/bash.exe"),
+            Some(root)
+        ));
+    }
+}

package/vendor/fastctx/src/shell/buffer.rs

@@ -0,0 +1,108 @@
+//! Bounded line-oriented storage for foreground command output.
+
+use crate::shell::normalize::NormalizedLine;
+use crate::shell::normalize::StreamEncoding;
+use std::collections::VecDeque;
+use std::mem::size_of;
+
+/// Maximum in-memory payload retained for one foreground command.
+pub(crate) const OUTPUT_BUFFER_BYTES: usize = 8 * 1024 * 1024;
+
+/// One normalized line stored with a stable, job-local sequence number.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct BufferedLine {
+    pub(crate) seq: u64,
+    pub(crate) bytes: Vec<u8>,
+    pub(crate) total_bytes: u64,
+    pub(crate) stream_encoding: Option<StreamEncoding>,
+    pub(crate) raw_truncated: bool,
+}
+
+impl BufferedLine {
+    fn storage_bytes(&self) -> usize {
+        size_of::<Self>()
+            .saturating_add(self.bytes.len())
+            .saturating_add(1)
+    }
+}
+
+/// An eight-megabyte ring that evicts only complete lines and never controls process life.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct LineRing {
+    lines: VecDeque<BufferedLine>,
+    storage_bytes: usize,
+    limit_bytes: usize,
+    next_seq: u64,
+    had_truncation: bool,
+    had_drop: bool,
+}
+
+impl LineRing {
+    pub(crate) fn new() -> Self {
+        Self::with_limit(OUTPUT_BUFFER_BYTES)
+    }
+
+    pub(crate) fn with_limit(limit_bytes: usize) -> Self {
+        Self {
+            lines: VecDeque::new(),
+            storage_bytes: 0,
+            limit_bytes,
+            next_seq: 1,
+            had_truncation: false,
+            had_drop: false,
+        }
+    }
+
+    /// Adds a line and returns its monotonically increasing sequence number.
+    pub(crate) fn push(&mut self, line: NormalizedLine) -> u64 {
+        let seq = self.next_seq;
+        self.next_seq = self.next_seq.saturating_add(1);
+        self.had_truncation |= line.raw_truncated;
+
+        let buffered = BufferedLine {
+            seq,
+            bytes: line.bytes,
+            total_bytes: line.total_bytes,
+            stream_encoding: line.stream_encoding,
+            raw_truncated: line.raw_truncated,
+        };
+        let required = buffered.storage_bytes();
+
+        while self.storage_bytes.saturating_add(required) > self.limit_bytes {
+            let Some(removed) = self.lines.pop_front() else {
+                break;
+            };
+            self.storage_bytes = self.storage_bytes.saturating_sub(removed.storage_bytes());
+            self.had_drop = true;
+        }
+
+        // A raw line prefix is bounded, but a deliberately tiny test ring can still
+        // be smaller than one record. Treat it as lost rather than violating the limit.
+        if required > self.limit_bytes {
+            self.had_drop = true;
+            return seq;
+        }
+
+        self.storage_bytes = self.storage_bytes.saturating_add(required);
+        self.lines.push_back(buffered);
+        seq
+    }
+
+    pub(crate) fn total_lines(&self) -> u64 {
+        self.next_seq.saturating_sub(1)
+    }
+
+    pub(crate) fn dropped_lines(&self) -> u64 {
+        self.total_lines().saturating_sub(self.lines.len() as u64)
+    }
+
+    pub(crate) fn all(&self) -> Vec<BufferedLine> {
+        self.lines.iter().cloned().collect()
+    }
+}
+
+impl Default for LineRing {
+    fn default() -> Self {
+        Self::new()
+    }
+}