command-stream 0.9.1 → 0.9.2

package/rust/src/quote.rs

@@ -0,0 +1,161 @@
+//! Shell quoting utilities for command-stream
+//!
+//! This module provides functions for safely quoting values for shell usage,
+//! preventing command injection and ensuring proper argument handling.
+
+/// Quote a value for safe shell usage
+///
+/// This function quotes strings appropriately for use in shell commands,
+/// handling special characters and edge cases.
+///
+/// # Examples
+///
+/// ```
+/// use command_stream::quote::quote;
+///
+/// // Safe characters are passed through unchanged
+/// assert_eq!(quote("hello"), "hello");
+/// assert_eq!(quote("/path/to/file"), "/path/to/file");
+///
+/// // Special characters are quoted
+/// assert_eq!(quote("hello world"), "'hello world'");
+///
+/// // Single quotes in strings are escaped
+/// assert_eq!(quote("it's"), "'it'\\''s'");
+///
+/// // Empty strings are quoted
+/// assert_eq!(quote(""), "''");
+/// ```
+pub fn quote(value: &str) -> String {
+    if value.is_empty() {
+        return "''".to_string();
+    }
+
+    // If already properly quoted with single quotes, check if we can use as-is
+    if value.starts_with('\'') && value.ends_with('\'') && value.len() >= 2 {
+        let inner = &value[1..value.len() - 1];
+        if !inner.contains('\'') {
+            return value.to_string();
+        }
+    }
+
+    // If already double-quoted, wrap in single quotes
+    if value.starts_with('"') && value.ends_with('"') && value.len() > 2 {
+        return format!("'{}'", value);
+    }
+
+    // Check if the string needs quoting at all
+    // Safe characters: alphanumeric, dash, underscore, dot, slash, colon, equals, comma, plus, at
+    let safe_pattern = regex::Regex::new(r"^[a-zA-Z0-9_\-./=,+@:]+$").unwrap();
+
+    if safe_pattern.is_match(value) {
+        return value.to_string();
+    }
+
+    // Default behavior: wrap in single quotes and escape any internal single quotes
+    // The shell escape sequence for a single quote inside single quotes is: '\''
+    // This ends the single quote, adds an escaped single quote, and starts single quotes again
+    format!("'{}'", value.replace('\'', "'\\''"))
+}
+
+/// Quote multiple values and join them with spaces
+///
+/// Convenience function for quoting a list of arguments.
+///
+/// # Examples
+///
+/// ```
+/// use command_stream::quote::quote_all;
+///
+/// let args = vec!["echo", "hello world", "test"];
+/// assert_eq!(quote_all(&args), "echo 'hello world' test");
+/// ```
+pub fn quote_all(values: &[&str]) -> String {
+    values
+        .iter()
+        .map(|v| quote(v))
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+/// Check if a string needs quoting for shell usage
+///
+/// Returns true if the string contains characters that would be interpreted
+/// specially by the shell.
+///
+/// # Examples
+///
+/// ```
+/// use command_stream::quote::needs_quoting;
+///
+/// assert!(!needs_quoting("hello"));
+/// assert!(needs_quoting("hello world"));
+/// assert!(needs_quoting("$PATH"));
+/// ```
+pub fn needs_quoting(value: &str) -> bool {
+    if value.is_empty() {
+        return true;
+    }
+
+    let safe_pattern = regex::Regex::new(r"^[a-zA-Z0-9_\-./=,+@:]+$").unwrap();
+    !safe_pattern.is_match(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_quote_empty() {
+        assert_eq!(quote(""), "''");
+    }
+
+    #[test]
+    fn test_quote_safe_chars() {
+        assert_eq!(quote("hello"), "hello");
+        assert_eq!(quote("/path/to/file"), "/path/to/file");
+        assert_eq!(quote("file.txt"), "file.txt");
+        assert_eq!(quote("key=value"), "key=value");
+        assert_eq!(quote("user@host"), "user@host");
+    }
+
+    #[test]
+    fn test_quote_special_chars() {
+        assert_eq!(quote("hello world"), "'hello world'");
+        assert_eq!(quote("it's"), "'it'\\''s'");
+        assert_eq!(quote("$var"), "'$var'");
+        assert_eq!(quote("test*"), "'test*'");
+    }
+
+    #[test]
+    fn test_quote_already_quoted() {
+        assert_eq!(quote("'already quoted'"), "'already quoted'");
+        assert_eq!(quote("\"double quoted\""), "'\"double quoted\"'");
+    }
+
+    #[test]
+    fn test_quote_all() {
+        let args = vec!["echo", "hello world", "test"];
+        assert_eq!(quote_all(&args), "echo 'hello world' test");
+    }
+
+    #[test]
+    fn test_needs_quoting() {
+        assert!(!needs_quoting("hello"));
+        assert!(!needs_quoting("/path/to/file"));
+        assert!(needs_quoting("hello world"));
+        assert!(needs_quoting("$PATH"));
+        assert!(needs_quoting(""));
+        assert!(needs_quoting("test*"));
+    }
+
+    #[test]
+    fn test_quote_with_newlines() {
+        assert_eq!(quote("line1\nline2"), "'line1\nline2'");
+    }
+
+    #[test]
+    fn test_quote_with_tabs() {
+        assert_eq!(quote("col1\tcol2"), "'col1\tcol2'");
+    }
+}

package/rust/src/state.rs

@@ -0,0 +1,333 @@
+//! Global state management for command-stream
+//!
+//! This module handles signal handlers, process tracking, and cleanup,
+//! similar to the JavaScript $.state.mjs module.
+
+use std::collections::HashSet;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+use crate::trace::trace_lazy;
+
+/// Shell settings for controlling execution behavior
+#[derive(Debug, Clone, Default)]
+pub struct ShellSettings {
+    /// Exit immediately if a command exits with non-zero status (set -e)
+    pub errexit: bool,
+    /// Print commands as they are executed (set -v)
+    pub verbose: bool,
+    /// Print trace of commands (set -x)
+    pub xtrace: bool,
+    /// Return value of a pipeline is the status of the last command to exit with non-zero (set -o pipefail)
+    pub pipefail: bool,
+    /// Treat unset variables as an error (set -u)
+    pub nounset: bool,
+    /// Disable filename globbing (set -f)
+    pub noglob: bool,
+    /// Export all variables (set -a)
+    pub allexport: bool,
+}
+
+impl ShellSettings {
+    /// Create new shell settings with defaults
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Reset all settings to their defaults
+    pub fn reset(&mut self) {
+        *self = Self::default();
+    }
+
+    /// Set a shell option by name
+    ///
+    /// Supports both short flags (e, v, x, u, f, a) and long names
+    pub fn set(&mut self, option: &str, value: bool) {
+        match option {
+            "e" | "errexit" => self.errexit = value,
+            "v" | "verbose" => self.verbose = value,
+            "x" | "xtrace" => self.xtrace = value,
+            "u" | "nounset" => self.nounset = value,
+            "f" | "noglob" => self.noglob = value,
+            "a" | "allexport" => self.allexport = value,
+            "o pipefail" | "pipefail" => self.pipefail = value,
+            _ => {
+                trace_lazy("ShellSettings", || {
+                    format!("Unknown shell option: {}", option)
+                });
+            }
+        }
+    }
+
+    /// Enable a shell option
+    pub fn enable(&mut self, option: &str) {
+        self.set(option, true);
+    }
+
+    /// Disable a shell option
+    pub fn disable(&mut self, option: &str) {
+        self.set(option, false);
+    }
+}
+
+/// Global state for the command-stream library
+pub struct GlobalState {
+    /// Current shell settings
+    shell_settings: RwLock<ShellSettings>,
+    /// Set of active process runner IDs
+    active_runners: RwLock<HashSet<u64>>,
+    /// Counter for generating runner IDs
+    next_runner_id: std::sync::atomic::AtomicU64,
+    /// Whether signal handlers are installed
+    signal_handlers_installed: AtomicBool,
+    /// Whether virtual commands are enabled
+    virtual_commands_enabled: AtomicBool,
+    /// Initial working directory
+    initial_cwd: RwLock<Option<std::path::PathBuf>>,
+}
+
+impl Default for GlobalState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GlobalState {
+    /// Create a new global state
+    pub fn new() -> Self {
+        let initial_cwd = std::env::current_dir().ok();
+
+        GlobalState {
+            shell_settings: RwLock::new(ShellSettings::new()),
+            active_runners: RwLock::new(HashSet::new()),
+            next_runner_id: std::sync::atomic::AtomicU64::new(1),
+            signal_handlers_installed: AtomicBool::new(false),
+            virtual_commands_enabled: AtomicBool::new(true),
+            initial_cwd: RwLock::new(initial_cwd),
+        }
+    }
+
+    /// Get the current shell settings
+    pub async fn get_shell_settings(&self) -> ShellSettings {
+        self.shell_settings.read().await.clone()
+    }
+
+    /// Set shell settings
+    pub async fn set_shell_settings(&self, settings: ShellSettings) {
+        *self.shell_settings.write().await = settings;
+    }
+
+    /// Modify shell settings with a closure
+    pub async fn with_shell_settings<F>(&self, f: F)
+    where
+        F: FnOnce(&mut ShellSettings),
+    {
+        let mut settings = self.shell_settings.write().await;
+        f(&mut settings);
+    }
+
+    /// Enable a shell option
+    pub async fn enable_shell_option(&self, option: &str) {
+        self.shell_settings.write().await.enable(option);
+    }
+
+    /// Disable a shell option
+    pub async fn disable_shell_option(&self, option: &str) {
+        self.shell_settings.write().await.disable(option);
+    }
+
+    /// Register a new active runner and return its ID
+    pub async fn register_runner(&self) -> u64 {
+        let id = self
+            .next_runner_id
+            .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        self.active_runners.write().await.insert(id);
+
+        trace_lazy("GlobalState", || {
+            format!("Registered runner {}", id)
+        });
+
+        id
+    }
+
+    /// Unregister an active runner
+    pub async fn unregister_runner(&self, id: u64) {
+        self.active_runners.write().await.remove(&id);
+
+        trace_lazy("GlobalState", || {
+            format!("Unregistered runner {}", id)
+        });
+    }
+
+    /// Get the count of active runners
+    pub async fn active_runner_count(&self) -> usize {
+        self.active_runners.read().await.len()
+    }
+
+    /// Check if signal handlers are installed
+    pub fn are_signal_handlers_installed(&self) -> bool {
+        self.signal_handlers_installed.load(Ordering::SeqCst)
+    }
+
+    /// Mark signal handlers as installed
+    pub fn set_signal_handlers_installed(&self, installed: bool) {
+        self.signal_handlers_installed.store(installed, Ordering::SeqCst);
+    }
+
+    /// Check if virtual commands are enabled
+    pub fn are_virtual_commands_enabled(&self) -> bool {
+        self.virtual_commands_enabled.load(Ordering::SeqCst)
+    }
+
+    /// Enable virtual commands
+    pub fn enable_virtual_commands(&self) {
+        self.virtual_commands_enabled.store(true, Ordering::SeqCst);
+        trace_lazy("GlobalState", || "Virtual commands enabled".to_string());
+    }
+
+    /// Disable virtual commands
+    pub fn disable_virtual_commands(&self) {
+        self.virtual_commands_enabled.store(false, Ordering::SeqCst);
+        trace_lazy("GlobalState", || "Virtual commands disabled".to_string());
+    }
+
+    /// Get the initial working directory
+    pub async fn get_initial_cwd(&self) -> Option<std::path::PathBuf> {
+        self.initial_cwd.read().await.clone()
+    }
+
+    /// Reset global state to defaults
+    pub async fn reset(&self) {
+        // Reset shell settings
+        *self.shell_settings.write().await = ShellSettings::new();
+
+        // Clear active runners
+        self.active_runners.write().await.clear();
+
+        // Reset virtual commands flag
+        self.virtual_commands_enabled.store(true, Ordering::SeqCst);
+
+        // Don't reset signal handlers installed flag - that's managed separately
+
+        trace_lazy("GlobalState", || "Global state reset completed".to_string());
+    }
+
+    /// Restore working directory to initial
+    pub async fn restore_cwd(&self) -> std::io::Result<()> {
+        if let Some(ref initial) = *self.initial_cwd.read().await {
+            if initial.exists() {
+                std::env::set_current_dir(initial)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Global state singleton
+static GLOBAL_STATE: std::sync::OnceLock<Arc<GlobalState>> = std::sync::OnceLock::new();
+
+/// Get the global state instance
+pub fn global_state() -> Arc<GlobalState> {
+    GLOBAL_STATE
+        .get_or_init(|| Arc::new(GlobalState::new()))
+        .clone()
+}
+
+/// Reset the global state (for testing)
+pub async fn reset_global_state() {
+    global_state().reset().await;
+}
+
+/// Get current shell settings
+pub async fn get_shell_settings() -> ShellSettings {
+    global_state().get_shell_settings().await
+}
+
+/// Enable a shell option globally
+pub async fn set_shell_option(option: &str) {
+    global_state().enable_shell_option(option).await;
+}
+
+/// Disable a shell option globally
+pub async fn unset_shell_option(option: &str) {
+    global_state().disable_shell_option(option).await;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_shell_settings_default() {
+        let settings = ShellSettings::new();
+        assert!(!settings.errexit);
+        assert!(!settings.verbose);
+        assert!(!settings.xtrace);
+        assert!(!settings.pipefail);
+        assert!(!settings.nounset);
+    }
+
+    #[test]
+    fn test_shell_settings_set() {
+        let mut settings = ShellSettings::new();
+
+        settings.set("e", true);
+        assert!(settings.errexit);
+
+        settings.set("errexit", false);
+        assert!(!settings.errexit);
+
+        settings.set("o pipefail", true);
+        assert!(settings.pipefail);
+    }
+
+    #[tokio::test]
+    async fn test_global_state_runners() {
+        let state = GlobalState::new();
+
+        let id1 = state.register_runner().await;
+        let id2 = state.register_runner().await;
+
+        assert_eq!(state.active_runner_count().await, 2);
+        assert!(id1 != id2);
+
+        state.unregister_runner(id1).await;
+        assert_eq!(state.active_runner_count().await, 1);
+
+        state.unregister_runner(id2).await;
+        assert_eq!(state.active_runner_count().await, 0);
+    }
+
+    #[tokio::test]
+    async fn test_global_state_virtual_commands() {
+        let state = GlobalState::new();
+
+        assert!(state.are_virtual_commands_enabled());
+
+        state.disable_virtual_commands();
+        assert!(!state.are_virtual_commands_enabled());
+
+        state.enable_virtual_commands();
+        assert!(state.are_virtual_commands_enabled());
+    }
+
+    #[tokio::test]
+    async fn test_global_state_reset() {
+        let state = GlobalState::new();
+
+        // Modify state
+        state.enable_shell_option("errexit").await;
+        state.register_runner().await;
+        state.disable_virtual_commands();
+
+        // Reset
+        state.reset().await;
+
+        // Verify reset
+        let settings = state.get_shell_settings().await;
+        assert!(!settings.errexit);
+        assert_eq!(state.active_runner_count().await, 0);
+        assert!(state.are_virtual_commands_enabled());
+    }
+}