command-stream 0.9.0 → 0.9.2

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());
+    }
+}

package/rust/src/stream.rs

@@ -0,0 +1,369 @@
+//! Streaming and async iteration support
+//!
+//! This module provides async streaming capabilities similar to JavaScript's
+//! async iterators and stream handling in `$.stream-utils.mjs`.
+//!
+//! ## Usage
+//!
+//! ```rust,no_run
+//! use command_stream::{StreamingRunner, OutputChunk};
+//!
+//! #[tokio::main]
+//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     let runner = StreamingRunner::new("yes hello");
+//!
+//!     // Stream output as it arrives
+//!     let mut stream = runner.stream();
+//!     let mut count = 0;
+//!     while let Some(chunk) = stream.next().await {
+//!         match chunk {
+//!             OutputChunk::Stdout(data) => {
+//!                 print!("{}", String::from_utf8_lossy(&data));
+//!                 count += 1;
+//!                 if count >= 5 {
+//!                     break;
+//!                 }
+//!             }
+//!             OutputChunk::Stderr(data) => {
+//!                 eprint!("{}", String::from_utf8_lossy(&data));
+//!             }
+//!             OutputChunk::Exit(code) => {
+//!                 println!("Process exited with code: {}", code);
+//!                 break;
+//!             }
+//!         }
+//!     }
+//!
+//!     Ok(())
+//! }
+//! ```
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::process::Stdio;
+use tokio::io::BufReader;
+use tokio::process::Command;
+use tokio::sync::mpsc;
+
+use crate::trace::trace_lazy;
+use crate::{CommandResult, Result};
+
+/// A chunk of output from a streaming process
+#[derive(Debug, Clone)]
+pub enum OutputChunk {
+    /// Stdout data
+    Stdout(Vec<u8>),
+    /// Stderr data
+    Stderr(Vec<u8>),
+    /// Process exit code
+    Exit(i32),
+}
+
+/// A streaming process runner that allows async iteration over output
+pub struct StreamingRunner {
+    command: String,
+    cwd: Option<PathBuf>,
+    env: Option<HashMap<String, String>>,
+    stdin_content: Option<String>,
+}
+
+impl StreamingRunner {
+    /// Create a new streaming runner
+    pub fn new(command: impl Into<String>) -> Self {
+        StreamingRunner {
+            command: command.into(),
+            cwd: None,
+            env: None,
+            stdin_content: None,
+        }
+    }
+
+    /// Set the working directory
+    pub fn cwd(mut self, path: impl Into<PathBuf>) -> Self {
+        self.cwd = Some(path.into());
+        self
+    }
+
+    /// Set environment variables
+    pub fn env(mut self, env: HashMap<String, String>) -> Self {
+        self.env = Some(env);
+        self
+    }
+
+    /// Set stdin content
+    pub fn stdin(mut self, content: impl Into<String>) -> Self {
+        self.stdin_content = Some(content.into());
+        self
+    }
+
+    /// Start the process and return a stream of output chunks
+    pub fn stream(mut self) -> OutputStream {
+        let (tx, rx) = mpsc::channel(1024);
+
+        // Spawn the process handling task
+        let command = self.command.clone();
+        let cwd = self.cwd.take();
+        let env = self.env.take();
+        let stdin_content = self.stdin_content.take();
+
+        tokio::spawn(async move {
+            if let Err(e) = run_streaming_process(command, cwd, env, stdin_content, tx.clone()).await {
+                trace_lazy("StreamingRunner", || format!("Error: {}", e));
+            }
+        });
+
+        OutputStream { rx }
+    }
+
+    /// Run to completion and collect all output
+    pub async fn collect(self) -> Result<CommandResult> {
+        let mut stdout = Vec::new();
+        let mut stderr = Vec::new();
+        let mut exit_code = 0;
+
+        let mut stream = self.stream();
+        while let Some(chunk) = stream.rx.recv().await {
+            match chunk {
+                OutputChunk::Stdout(data) => stdout.extend(data),
+                OutputChunk::Stderr(data) => stderr.extend(data),
+                OutputChunk::Exit(code) => exit_code = code,
+            }
+        }
+
+        Ok(CommandResult {
+            stdout: String::from_utf8_lossy(&stdout).to_string(),
+            stderr: String::from_utf8_lossy(&stderr).to_string(),
+            code: exit_code,
+        })
+    }
+}
+
+/// Stream of output chunks from a process
+pub struct OutputStream {
+    rx: mpsc::Receiver<OutputChunk>,
+}
+
+impl OutputStream {
+    /// Receive the next chunk
+    pub async fn next(&mut self) -> Option<OutputChunk> {
+        self.rx.recv().await
+    }
+
+    /// Collect all remaining output into vectors
+    pub async fn collect(mut self) -> (Vec<u8>, Vec<u8>, i32) {
+        let mut stdout = Vec::new();
+        let mut stderr = Vec::new();
+        let mut exit_code = 0;
+
+        while let Some(chunk) = self.rx.recv().await {
+            match chunk {
+                OutputChunk::Stdout(data) => stdout.extend(data),
+                OutputChunk::Stderr(data) => stderr.extend(data),
+                OutputChunk::Exit(code) => exit_code = code,
+            }
+        }
+
+        (stdout, stderr, exit_code)
+    }
+
+    /// Collect stdout only, discarding stderr
+    pub async fn collect_stdout(mut self) -> Vec<u8> {
+        let mut stdout = Vec::new();
+
+        while let Some(chunk) = self.rx.recv().await {
+            if let OutputChunk::Stdout(data) = chunk {
+                stdout.extend(data);
+            }
+        }
+
+        stdout
+    }
+}
+
+/// Run a streaming process and send output to the channel
+async fn run_streaming_process(
+    command: String,
+    cwd: Option<PathBuf>,
+    env: Option<HashMap<String, String>>,
+    stdin_content: Option<String>,
+    tx: mpsc::Sender<OutputChunk>,
+) -> Result<()> {
+    trace_lazy("StreamingRunner", || format!("Starting: {}", command));
+
+    let shell = find_available_shell();
+    let mut cmd = Command::new(&shell.cmd);
+    for arg in &shell.args {
+        cmd.arg(arg);
+    }
+    cmd.arg(&command);
+
+    // Configure stdio
+    if stdin_content.is_some() {
+        cmd.stdin(Stdio::piped());
+    } else {
+        cmd.stdin(Stdio::null());
+    }
+    cmd.stdout(Stdio::piped());
+    cmd.stderr(Stdio::piped());
+
+    // Set working directory
+    if let Some(ref cwd) = cwd {
+        cmd.current_dir(cwd);
+    }
+
+    // Set environment
+    if let Some(ref env_vars) = env {
+        for (key, value) in env_vars {
+            cmd.env(key, value);
+        }
+    }
+
+    // Spawn the process
+    let mut child = cmd.spawn()?;
+
+    // Write stdin if needed
+    if let Some(content) = stdin_content {
+        if let Some(mut stdin) = child.stdin.take() {
+            use tokio::io::AsyncWriteExt;
+            let _ = stdin.write_all(content.as_bytes()).await;
+            let _ = stdin.shutdown().await;
+        }
+    }
+
+    // Spawn stdout reader
+    let stdout = child.stdout.take();
+    let tx_stdout = tx.clone();
+    let stdout_handle = if let Some(stdout) = stdout {
+        Some(tokio::spawn(async move {
+            let mut reader = BufReader::new(stdout);
+            let mut buf = vec![0u8; 8192];
+            loop {
+                use tokio::io::AsyncReadExt;
+                match reader.read(&mut buf).await {
+                    Ok(0) => break,
+                    Ok(n) => {
+                        if tx_stdout.send(OutputChunk::Stdout(buf[..n].to_vec())).await.is_err() {
+                            break;
+                        }
+                    }
+                    Err(_) => break,
+                }
+            }
+        }))
+    } else {
+        None
+    };
+
+    // Spawn stderr reader
+    let stderr = child.stderr.take();
+    let tx_stderr = tx.clone();
+    let stderr_handle = if let Some(stderr) = stderr {
+        Some(tokio::spawn(async move {
+            let mut reader = BufReader::new(stderr);
+            let mut buf = vec![0u8; 8192];
+            loop {
+                use tokio::io::AsyncReadExt;
+                match reader.read(&mut buf).await {
+                    Ok(0) => break,
+                    Ok(n) => {
+                        if tx_stderr.send(OutputChunk::Stderr(buf[..n].to_vec())).await.is_err() {
+                            break;
+                        }
+                    }
+                    Err(_) => break,
+                }
+            }
+        }))
+    } else {
+        None
+    };
+
+    // Wait for readers to complete
+    if let Some(handle) = stdout_handle {
+        let _ = handle.await;
+    }
+    if let Some(handle) = stderr_handle {
+        let _ = handle.await;
+    }
+
+    // Wait for process to exit
+    let status = child.wait().await?;
+    let code = status.code().unwrap_or(-1);
+
+    // Send exit code
+    let _ = tx.send(OutputChunk::Exit(code)).await;
+
+    trace_lazy("StreamingRunner", || format!("Exited with code: {}", code));
+
+    Ok(())
+}
+
+/// Shell configuration
+#[derive(Debug, Clone)]
+struct ShellConfig {
+    cmd: String,
+    args: Vec<String>,
+}
+
+/// Find an available shell
+fn find_available_shell() -> ShellConfig {
+    let is_windows = cfg!(windows);
+
+    if is_windows {
+        ShellConfig {
+            cmd: "cmd.exe".to_string(),
+            args: vec!["/c".to_string()],
+        }
+    } else {
+        let shells = [
+            ("/bin/sh", "-c"),
+            ("/usr/bin/sh", "-c"),
+            ("/bin/bash", "-c"),
+        ];
+
+        for (cmd, arg) in shells {
+            if std::path::Path::new(cmd).exists() {
+                return ShellConfig {
+                    cmd: cmd.to_string(),
+                    args: vec![arg.to_string()],
+                };
+            }
+        }
+
+        ShellConfig {
+            cmd: "/bin/sh".to_string(),
+            args: vec!["-c".to_string()],
+        }
+    }
+}
+
+/// Async iterator trait for output streams
+#[async_trait::async_trait]
+pub trait AsyncIterator {
+    type Item;
+
+    /// Get the next item from the iterator
+    async fn next(&mut self) -> Option<Self::Item>;
+}
+
+#[async_trait::async_trait]
+impl AsyncIterator for OutputStream {
+    type Item = OutputChunk;
+
+    async fn next(&mut self) -> Option<Self::Item> {
+        self.rx.recv().await
+    }
+}
+
+/// Extension trait to convert ProcessRunner into a stream
+pub trait IntoStream {
+    /// Convert into an output stream
+    fn into_stream(self) -> OutputStream;
+}
+
+impl IntoStream for crate::ProcessRunner {
+    fn into_stream(self) -> OutputStream {
+        let streaming = StreamingRunner::new(self.command().to_string());
+        streaming.stream()
+    }
+}