command-stream 0.8.2 → 0.9.0

package/rust/src/commands/false.rs

@@ -0,0 +1,24 @@
+//! Virtual `false` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::CommandResult;
+
+/// Execute the false command
+///
+/// Always returns failure (exit code 1).
+pub async fn r#false(_ctx: CommandContext) -> CommandResult {
+    CommandResult::error_with_code("", 1)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_false() {
+        let ctx = CommandContext::new(vec![]);
+        let result = r#false(ctx).await;
+        assert!(!result.is_success());
+        assert_eq!(result.code, 1);
+    }
+}

package/rust/src/commands/ls.rs

@@ -0,0 +1,182 @@
+//! Virtual `ls` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace_lazy, CommandResult};
+use std::fs;
+use std::path::Path;
+
+/// Execute the ls command
+///
+/// Lists directory contents.
+pub async fn ls(ctx: CommandContext) -> CommandResult {
+    // Parse flags
+    let mut show_all = false;
+    let mut long_format = false;
+    let mut paths = Vec::new();
+
+    for arg in &ctx.args {
+        if arg == "-a" || arg == "--all" {
+            show_all = true;
+        } else if arg == "-l" {
+            long_format = true;
+        } else if arg == "-la" || arg == "-al" {
+            show_all = true;
+            long_format = true;
+        } else if arg.starts_with('-') {
+            if arg.contains('a') {
+                show_all = true;
+            }
+            if arg.contains('l') {
+                long_format = true;
+            }
+        } else {
+            paths.push(arg.clone());
+        }
+    }
+
+    // Default to current directory
+    if paths.is_empty() {
+        paths.push(".".to_string());
+    }
+
+    let cwd = ctx.get_cwd();
+    let mut outputs = Vec::new();
+
+    for path_str in paths {
+        let resolved_path = if Path::new(&path_str).is_absolute() {
+            Path::new(&path_str).to_path_buf()
+        } else {
+            cwd.join(&path_str)
+        };
+
+        trace_lazy("VirtualCommand", || {
+            format!("ls: listing {:?}", resolved_path)
+        });
+
+        if !resolved_path.exists() {
+            return CommandResult::error(format!(
+                "ls: cannot access '{}': No such file or directory\n",
+                path_str
+            ));
+        }
+
+        if resolved_path.is_file() {
+            outputs.push(format_entry(&resolved_path, long_format));
+        } else {
+            match fs::read_dir(&resolved_path) {
+                Ok(entries) => {
+                    let mut entry_strs = Vec::new();
+
+                    for entry in entries {
+                        if let Ok(entry) = entry {
+                            let name = entry.file_name().to_string_lossy().to_string();
+
+                            // Skip hidden files unless -a is specified
+                            if !show_all && name.starts_with('.') {
+                                continue;
+                            }
+
+                            if long_format {
+                                entry_strs.push(format_entry(&entry.path(), true));
+                            } else {
+                                entry_strs.push(name);
+                            }
+                        }
+                    }
+
+                    entry_strs.sort();
+                    outputs.push(entry_strs.join("\n"));
+                }
+                Err(e) => {
+                    return CommandResult::error(format!("ls: cannot open '{}': {}\n", path_str, e));
+                }
+            }
+        }
+    }
+
+    let output = outputs.join("\n");
+    if output.is_empty() {
+        CommandResult::success_empty()
+    } else {
+        CommandResult::success(format!("{}\n", output))
+    }
+}
+
+fn format_entry(path: &Path, long_format: bool) -> String {
+    let name = path.file_name()
+        .map(|n| n.to_string_lossy().to_string())
+        .unwrap_or_else(|| path.display().to_string());
+
+    if !long_format {
+        return name;
+    }
+
+    // Long format: permissions, links, owner, group, size, date, name
+    let metadata = match fs::metadata(path) {
+        Ok(m) => m,
+        Err(_) => return name,
+    };
+
+    let file_type = if metadata.is_dir() { "d" } else { "-" };
+    let size = metadata.len();
+
+    // Simplified permissions
+    let perms = if metadata.is_dir() {
+        "drwxr-xr-x"
+    } else {
+        "-rw-r--r--"
+    };
+
+    format!("{} {:>8} {}", perms, size, name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn test_ls_current_dir() {
+        let ctx = CommandContext::new(vec![]);
+        let result = ls(ctx).await;
+        assert!(result.is_success());
+    }
+
+    #[tokio::test]
+    async fn test_ls_with_path() {
+        let temp = tempdir().unwrap();
+        fs::write(temp.path().join("file.txt"), "test").unwrap();
+
+        let ctx = CommandContext::new(vec![
+            temp.path().to_string_lossy().to_string()
+        ]);
+        let result = ls(ctx).await;
+
+        assert!(result.is_success());
+        assert!(result.stdout.contains("file.txt"));
+    }
+
+    #[tokio::test]
+    async fn test_ls_hidden_files() {
+        let temp = tempdir().unwrap();
+        fs::write(temp.path().join(".hidden"), "test").unwrap();
+        fs::write(temp.path().join("visible"), "test").unwrap();
+
+        // Without -a
+        let ctx = CommandContext::new(vec![
+            temp.path().to_string_lossy().to_string()
+        ]);
+        let result = ls(ctx).await;
+        assert!(!result.stdout.contains(".hidden"));
+        assert!(result.stdout.contains("visible"));
+
+        // With -a
+        let ctx = CommandContext::new(vec![
+            "-a".to_string(),
+            temp.path().to_string_lossy().to_string(),
+        ]);
+        let result = ls(ctx).await;
+        assert!(result.stdout.contains(".hidden"));
+        assert!(result.stdout.contains("visible"));
+    }
+}

package/rust/src/commands/mkdir.rs

@@ -0,0 +1,98 @@
+//! Virtual `mkdir` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace_lazy, CommandResult, VirtualUtils};
+use std::fs;
+
+/// Execute the mkdir command
+///
+/// Creates directories.
+pub async fn mkdir(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        return VirtualUtils::missing_operand_error("mkdir");
+    }
+
+    // Check for -p flag
+    let mut create_parents = false;
+    let mut dirs = Vec::new();
+
+    for arg in &ctx.args {
+        if arg == "-p" {
+            create_parents = true;
+        } else if arg.starts_with('-') {
+            // Skip other flags
+        } else {
+            dirs.push(arg.clone());
+        }
+    }
+
+    if dirs.is_empty() {
+        return VirtualUtils::missing_operand_error("mkdir");
+    }
+
+    let cwd = ctx.get_cwd();
+
+    for dir in dirs {
+        let resolved_path = VirtualUtils::resolve_path(&dir, Some(&cwd));
+
+        trace_lazy("VirtualCommand", || {
+            format!("mkdir: creating directory {:?}, parents: {}", resolved_path, create_parents)
+        });
+
+        let result = if create_parents {
+            fs::create_dir_all(&resolved_path)
+        } else {
+            fs::create_dir(&resolved_path)
+        };
+
+        if let Err(e) = result {
+            return CommandResult::error(format!("mkdir: cannot create directory '{}': {}\n", dir, e));
+        }
+    }
+
+    CommandResult::success_empty()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn test_mkdir_simple() {
+        let temp = tempdir().unwrap();
+        let new_dir = temp.path().join("new_directory");
+
+        let ctx = CommandContext::new(vec![
+            new_dir.to_string_lossy().to_string()
+        ]);
+        let result = mkdir(ctx).await;
+
+        assert!(result.is_success());
+        assert!(new_dir.exists());
+    }
+
+    #[tokio::test]
+    async fn test_mkdir_with_parents() {
+        let temp = tempdir().unwrap();
+        let nested_dir = temp.path().join("a/b/c/d");
+
+        let ctx = CommandContext::new(vec![
+            "-p".to_string(),
+            nested_dir.to_string_lossy().to_string(),
+        ]);
+        let result = mkdir(ctx).await;
+
+        assert!(result.is_success());
+        assert!(nested_dir.exists());
+    }
+
+    #[tokio::test]
+    async fn test_mkdir_missing_operand() {
+        let ctx = CommandContext::new(vec![]);
+        let result = mkdir(ctx).await;
+
+        assert!(!result.is_success());
+        assert!(result.stderr.contains("missing operand"));
+    }
+}

package/rust/src/commands/mod.rs

@@ -0,0 +1,200 @@
+//! Virtual command implementations
+//!
+//! This module contains implementations of shell commands that run in-process
+//! without spawning external processes. These provide faster execution and
+//! consistent behavior across platforms.
+
+mod cat;
+mod cd;
+mod echo;
+mod pwd;
+mod sleep;
+mod r#true;
+mod r#false;
+mod mkdir;
+mod rm;
+mod touch;
+mod ls;
+mod cp;
+mod mv;
+mod basename;
+mod dirname;
+mod env;
+mod exit;
+mod which;
+mod yes;
+mod seq;
+mod test;
+
+pub use cat::cat;
+pub use cd::cd;
+pub use echo::echo;
+pub use pwd::pwd;
+pub use sleep::sleep;
+pub use r#true::r#true;
+pub use r#false::r#false;
+pub use mkdir::mkdir;
+pub use rm::rm;
+pub use touch::touch;
+pub use ls::ls;
+pub use cp::cp;
+pub use mv::mv;
+pub use basename::basename;
+pub use dirname::dirname;
+pub use env::env;
+pub use exit::exit;
+pub use which::which;
+pub use yes::yes;
+pub use seq::seq;
+pub use test::test;
+
+use crate::utils::CommandResult;
+use std::collections::HashMap;
+use std::path::Path;
+use tokio::sync::mpsc;
+
+/// Context for virtual command execution
+pub struct CommandContext {
+    /// Command arguments (excluding the command name)
+    pub args: Vec<String>,
+    /// Standard input content
+    pub stdin: Option<String>,
+    /// Current working directory
+    pub cwd: Option<std::path::PathBuf>,
+    /// Environment variables
+    pub env: Option<HashMap<String, String>>,
+    /// Channel to send streaming output
+    pub output_tx: Option<mpsc::Sender<StreamChunk>>,
+    /// Cancellation check function
+    pub is_cancelled: Option<Box<dyn Fn() -> bool + Send + Sync>>,
+}
+
+impl std::fmt::Debug for CommandContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CommandContext")
+            .field("args", &self.args)
+            .field("stdin", &self.stdin)
+            .field("cwd", &self.cwd)
+            .field("env", &self.env)
+            .field("output_tx", &self.output_tx.is_some())
+            .field("is_cancelled", &self.is_cancelled.is_some())
+            .finish()
+    }
+}
+
+/// A chunk of streaming output
+#[derive(Debug, Clone)]
+pub enum StreamChunk {
+    Stdout(String),
+    Stderr(String),
+}
+
+impl CommandContext {
+    /// Create a new command context with arguments
+    pub fn new(args: Vec<String>) -> Self {
+        CommandContext {
+            args,
+            stdin: None,
+            cwd: None,
+            env: None,
+            output_tx: None,
+            is_cancelled: None,
+        }
+    }
+
+    /// Check if the command has been cancelled
+    pub fn is_cancelled(&self) -> bool {
+        self.is_cancelled
+            .as_ref()
+            .map(|f| f())
+            .unwrap_or(false)
+    }
+
+    /// Get the current working directory
+    pub fn get_cwd(&self) -> std::path::PathBuf {
+        self.cwd.clone().unwrap_or_else(|| {
+            std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("/"))
+        })
+    }
+}
+
+/// Type for virtual command handler functions
+pub type VirtualCommandHandler = fn(CommandContext) -> std::pin::Pin<Box<dyn std::future::Future<Output = CommandResult> + Send>>;
+
+/// Registry of virtual commands
+pub struct VirtualCommandRegistry {
+    commands: HashMap<String, VirtualCommandHandler>,
+}
+
+impl Default for VirtualCommandRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl VirtualCommandRegistry {
+    /// Create a new empty registry
+    pub fn new() -> Self {
+        VirtualCommandRegistry {
+            commands: HashMap::new(),
+        }
+    }
+
+    /// Create a registry with all built-in commands registered
+    pub fn with_builtins() -> Self {
+        let mut registry = Self::new();
+        registry.register_builtins();
+        registry
+    }
+
+    /// Register a virtual command
+    pub fn register(&mut self, name: &str, handler: VirtualCommandHandler) {
+        self.commands.insert(name.to_string(), handler);
+    }
+
+    /// Unregister a virtual command
+    pub fn unregister(&mut self, name: &str) -> bool {
+        self.commands.remove(name).is_some()
+    }
+
+    /// Get a virtual command handler
+    pub fn get(&self, name: &str) -> Option<&VirtualCommandHandler> {
+        self.commands.get(name)
+    }
+
+    /// Check if a command is registered
+    pub fn contains(&self, name: &str) -> bool {
+        self.commands.contains_key(name)
+    }
+
+    /// List all registered command names
+    pub fn list(&self) -> Vec<&str> {
+        self.commands.keys().map(|s| s.as_str()).collect()
+    }
+
+    /// Register all built-in commands
+    pub fn register_builtins(&mut self) {
+        // Note: These are placeholder registrations - actual async handlers
+        // would need proper wrapper functions
+        // The actual commands are available as standalone functions
+    }
+}
+
+/// Global virtual commands enabled flag
+static VIRTUAL_COMMANDS_ENABLED: std::sync::atomic::AtomicBool =
+    std::sync::atomic::AtomicBool::new(true);
+
+/// Enable virtual commands
+pub fn enable_virtual_commands() {
+    VIRTUAL_COMMANDS_ENABLED.store(true, std::sync::atomic::Ordering::SeqCst);
+}
+
+/// Disable virtual commands
+pub fn disable_virtual_commands() {
+    VIRTUAL_COMMANDS_ENABLED.store(false, std::sync::atomic::Ordering::SeqCst);
+}
+
+/// Check if virtual commands are enabled
+pub fn are_virtual_commands_enabled() -> bool {
+    VIRTUAL_COMMANDS_ENABLED.load(std::sync::atomic::Ordering::SeqCst)
+}

package/rust/src/commands/mv.rs

@@ -0,0 +1,180 @@
+//! Virtual `mv` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace_lazy, CommandResult, VirtualUtils};
+use std::fs;
+
+/// Execute the mv command
+///
+/// Moves (renames) files and directories.
+pub async fn mv(ctx: CommandContext) -> CommandResult {
+    if ctx.args.len() < 2 {
+        return VirtualUtils::invalid_argument_error("mv", "missing file operand");
+    }
+
+    // Parse flags (currently just skip them)
+    let mut paths = Vec::new();
+
+    for arg in &ctx.args {
+        if !arg.starts_with('-') {
+            paths.push(arg.clone());
+        }
+    }
+
+    if paths.len() < 2 {
+        return VirtualUtils::invalid_argument_error("mv", "missing destination file operand");
+    }
+
+    let cwd = ctx.get_cwd();
+    let dest = paths.pop().unwrap();
+    let dest_path = VirtualUtils::resolve_path(&dest, Some(&cwd));
+
+    // If multiple sources or dest is a directory, move into the directory
+    let dest_is_dir = dest_path.is_dir();
+    let multiple_sources = paths.len() > 1;
+
+    if multiple_sources && !dest_is_dir {
+        return CommandResult::error(format!(
+            "mv: target '{}' is not a directory\n",
+            dest
+        ));
+    }
+
+    for source in paths {
+        let source_path = VirtualUtils::resolve_path(&source, Some(&cwd));
+
+        trace_lazy("VirtualCommand", || {
+            format!("mv: moving {:?} to {:?}", source_path, dest_path)
+        });
+
+        if !source_path.exists() {
+            return CommandResult::error(format!(
+                "mv: cannot stat '{}': No such file or directory\n",
+                source
+            ));
+        }
+
+        let final_dest = if dest_is_dir {
+            dest_path.join(source_path.file_name().unwrap_or_default())
+        } else {
+            dest_path.clone()
+        };
+
+        // Try rename first (fastest if on same filesystem)
+        match fs::rename(&source_path, &final_dest) {
+            Ok(()) => continue,
+            Err(e) => {
+                // If rename fails (e.g., cross-filesystem), try copy + delete
+                if e.kind() == std::io::ErrorKind::CrossesDevices
+                    || e.kind() == std::io::ErrorKind::Other
+                {
+                    if source_path.is_dir() {
+                        if let Err(e) = copy_and_remove_dir(&source_path, &final_dest) {
+                            return CommandResult::error(format!(
+                                "mv: cannot move '{}': {}\n",
+                                source, e
+                            ));
+                        }
+                    } else {
+                        if let Err(e) = fs::copy(&source_path, &final_dest) {
+                            return CommandResult::error(format!(
+                                "mv: cannot move '{}': {}\n",
+                                source, e
+                            ));
+                        }
+                        if let Err(e) = fs::remove_file(&source_path) {
+                            return CommandResult::error(format!(
+                                "mv: cannot remove '{}': {}\n",
+                                source, e
+                            ));
+                        }
+                    }
+                } else {
+                    return CommandResult::error(format!(
+                        "mv: cannot move '{}': {}\n",
+                        source, e
+                    ));
+                }
+            }
+        }
+    }
+
+    CommandResult::success_empty()
+}
+
+fn copy_and_remove_dir(src: &std::path::Path, dst: &std::path::Path) -> std::io::Result<()> {
+    fs::create_dir_all(dst)?;
+
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let entry_path = entry.path();
+        let dest_path = dst.join(entry.file_name());
+
+        if entry_path.is_dir() {
+            copy_and_remove_dir(&entry_path, &dest_path)?;
+        } else {
+            fs::copy(&entry_path, &dest_path)?;
+        }
+    }
+
+    fs::remove_dir_all(src)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn test_mv_file() {
+        let temp = tempdir().unwrap();
+        let src = temp.path().join("source.txt");
+        let dst = temp.path().join("dest.txt");
+        fs::write(&src, "test content").unwrap();
+
+        let ctx = CommandContext::new(vec![
+            src.to_string_lossy().to_string(),
+            dst.to_string_lossy().to_string(),
+        ]);
+        let result = mv(ctx).await;
+
+        assert!(result.is_success());
+        assert!(!src.exists());
+        assert!(dst.exists());
+        assert_eq!(fs::read_to_string(&dst).unwrap(), "test content");
+    }
+
+    #[tokio::test]
+    async fn test_mv_directory() {
+        let temp = tempdir().unwrap();
+        let src_dir = temp.path().join("src_dir");
+        let dst_dir = temp.path().join("dst_dir");
+
+        fs::create_dir(&src_dir).unwrap();
+        fs::write(src_dir.join("file.txt"), "test").unwrap();
+
+        let ctx = CommandContext::new(vec![
+            src_dir.to_string_lossy().to_string(),
+            dst_dir.to_string_lossy().to_string(),
+        ]);
+        let result = mv(ctx).await;
+
+        assert!(result.is_success());
+        assert!(!src_dir.exists());
+        assert!(dst_dir.join("file.txt").exists());
+    }
+
+    #[tokio::test]
+    async fn test_mv_nonexistent() {
+        let temp = tempdir().unwrap();
+
+        let ctx = CommandContext::new(vec![
+            "/nonexistent/file".to_string(),
+            temp.path().join("dest").to_string_lossy().to_string(),
+        ]);
+        let result = mv(ctx).await;
+
+        assert!(!result.is_success());
+    }
+}

package/rust/src/commands/pwd.rs

@@ -0,0 +1,28 @@
+//! Virtual `pwd` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::CommandResult;
+use std::env;
+
+/// Execute the pwd command
+///
+/// Prints the current working directory.
+pub async fn pwd(_ctx: CommandContext) -> CommandResult {
+    match env::current_dir() {
+        Ok(path) => CommandResult::success(format!("{}\n", path.display())),
+        Err(e) => CommandResult::error(format!("pwd: {}\n", e)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_pwd() {
+        let ctx = CommandContext::new(vec![]);
+        let result = pwd(ctx).await;
+        assert!(result.is_success());
+        assert!(!result.stdout.is_empty());
+    }
+}