command-stream 0.8.2 → 0.9.0

package/rust/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "command-stream"
+version = "0.8.3"
+edition = "2021"
+authors = ["link-foundation"]
+description = "Modern shell command execution library with streaming, async iteration, and event support"
+license = "Unlicense"
+repository = "https://github.com/link-foundation/command-stream"
+keywords = ["shell", "command", "streaming", "async", "process"]
+categories = ["command-line-utilities", "asynchronous"]
+readme = "../README.md"
+
+[lib]
+name = "command_stream"
+path = "src/lib.rs"
+
+[[bin]]
+name = "command-stream"
+path = "src/main.rs"
+
+[dependencies]
+tokio = { version = "1.43", features = ["full", "process", "signal"] }
+async-trait = "0.1"
+thiserror = "2.0"
+once_cell = "1.20"
+regex = "1.11"
+serde = { version = "1.0", features = ["derive"], optional = true }
+serde_json = { version = "1.0", optional = true }
+nix = { version = "0.29", features = ["signal", "process"] }
+libc = "0.2"
+which = "7.0"
+glob = "0.3"
+chrono = "0.4"
+filetime = "0.2"
+
+[dev-dependencies]
+tokio-test = "0.4"
+tempfile = "3.14"
+assert_cmd = "2.0"
+
+[features]
+default = []
+json = ["serde", "serde_json"]
+
+[profile.release]
+opt-level = 3
+lto = true

package/rust/src/commands/basename.rs

@@ -0,0 +1,69 @@
+//! Virtual `basename` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{CommandResult, VirtualUtils};
+use std::path::Path;
+
+/// Execute the basename command
+///
+/// Strips directory and suffix from filenames.
+pub async fn basename(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        return VirtualUtils::missing_operand_error("basename");
+    }
+
+    let path = &ctx.args[0];
+    let suffix = ctx.args.get(1);
+
+    let base = Path::new(path)
+        .file_name()
+        .map(|n| n.to_string_lossy().to_string())
+        .unwrap_or_default();
+
+    let result = if let Some(suf) = suffix {
+        if base.ends_with(suf.as_str()) {
+            base[..base.len() - suf.len()].to_string()
+        } else {
+            base
+        }
+    } else {
+        base
+    };
+
+    CommandResult::success(format!("{}\n", result))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_basename_simple() {
+        let ctx = CommandContext::new(vec!["/path/to/file.txt".to_string()]);
+        let result = basename(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "file.txt\n");
+    }
+
+    #[tokio::test]
+    async fn test_basename_with_suffix() {
+        let ctx = CommandContext::new(vec![
+            "/path/to/file.txt".to_string(),
+            ".txt".to_string(),
+        ]);
+        let result = basename(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "file\n");
+    }
+
+    #[tokio::test]
+    async fn test_basename_no_path() {
+        let ctx = CommandContext::new(vec!["file.txt".to_string()]);
+        let result = basename(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "file.txt\n");
+    }
+}

package/rust/src/commands/cat.rs

@@ -0,0 +1,123 @@
+//! Virtual `cat` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace_lazy, CommandResult, VirtualUtils};
+use std::fs;
+
+/// Execute the cat command
+///
+/// Concatenates and displays file contents.
+pub async fn cat(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        // Read from stdin if no files specified
+        if let Some(ref stdin) = ctx.stdin {
+            if !stdin.is_empty() {
+                return CommandResult::success(stdin.clone());
+            }
+        }
+        return CommandResult::success_empty();
+    }
+
+    let cwd = ctx.get_cwd();
+    let mut outputs = Vec::new();
+
+    for file in &ctx.args {
+        // Check for cancellation before processing each file
+        if ctx.is_cancelled() {
+            trace_lazy("VirtualCommand", || {
+                "cat: cancelled while processing files".to_string()
+            });
+            return CommandResult::error_with_code("", 130); // SIGINT exit code
+        }
+
+        trace_lazy("VirtualCommand", || {
+            format!("cat: reading file {:?}", file)
+        });
+
+        let resolved_path = VirtualUtils::resolve_path(file, Some(&cwd));
+
+        match fs::read_to_string(&resolved_path) {
+            Ok(content) => {
+                outputs.push(content);
+            }
+            Err(e) => {
+                let error_msg = if e.kind() == std::io::ErrorKind::NotFound {
+                    format!("cat: {}: No such file or directory\n", file)
+                } else if e.kind() == std::io::ErrorKind::IsADirectory
+                    || (e.kind() == std::io::ErrorKind::Other && e.to_string().contains("directory"))
+                {
+                    format!("cat: {}: Is a directory\n", file)
+                } else {
+                    format!("cat: {}: {}\n", file, e)
+                };
+                return CommandResult::error(error_msg);
+            }
+        }
+    }
+
+    let output = outputs.join("");
+    trace_lazy("VirtualCommand", || {
+        format!("cat: success, bytes read: {}", output.len())
+    });
+
+    CommandResult::success(output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    #[tokio::test]
+    async fn test_cat_file() {
+        let mut temp = NamedTempFile::new().unwrap();
+        writeln!(temp, "Hello, World!").unwrap();
+
+        let ctx = CommandContext::new(vec![
+            temp.path().to_string_lossy().to_string()
+        ]);
+        let result = cat(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "Hello, World!\n");
+    }
+
+    #[tokio::test]
+    async fn test_cat_stdin() {
+        let mut ctx = CommandContext::new(vec![]);
+        ctx.stdin = Some("stdin content".to_string());
+
+        let result = cat(ctx).await;
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "stdin content");
+    }
+
+    #[tokio::test]
+    async fn test_cat_nonexistent() {
+        let ctx = CommandContext::new(vec![
+            "/nonexistent/file/12345".to_string()
+        ]);
+        let result = cat(ctx).await;
+
+        assert!(!result.is_success());
+        assert!(result.stderr.contains("No such file or directory"));
+    }
+
+    #[tokio::test]
+    async fn test_cat_multiple_files() {
+        let mut temp1 = NamedTempFile::new().unwrap();
+        let mut temp2 = NamedTempFile::new().unwrap();
+        write!(temp1, "file1").unwrap();
+        write!(temp2, "file2").unwrap();
+
+        let ctx = CommandContext::new(vec![
+            temp1.path().to_string_lossy().to_string(),
+            temp2.path().to_string_lossy().to_string(),
+        ]);
+        let result = cat(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "file1file2");
+    }
+}

package/rust/src/commands/cd.rs

@@ -0,0 +1,67 @@
+//! Virtual `cd` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace, CommandResult};
+use std::env;
+use std::path::PathBuf;
+
+/// Execute the cd command
+///
+/// Changes the current working directory.
+pub async fn cd(ctx: CommandContext) -> CommandResult {
+    let target = if ctx.args.is_empty() {
+        // No argument - go to home directory
+        env::var("HOME")
+            .or_else(|_| env::var("USERPROFILE"))
+            .unwrap_or_else(|_| "/".to_string())
+    } else {
+        ctx.args[0].clone()
+    };
+
+    trace("VirtualCommand", &format!("cd: changing directory to {:?}", target));
+
+    let path = PathBuf::from(&target);
+
+    match env::set_current_dir(&path) {
+        Ok(()) => {
+            let new_dir = env::current_dir()
+                .map(|p| p.display().to_string())
+                .unwrap_or_default();
+            trace("VirtualCommand", &format!("cd: success, new dir: {}", new_dir));
+            // cd command should not output anything on success
+            CommandResult::success_empty()
+        }
+        Err(e) => {
+            trace("VirtualCommand", &format!("cd: failed: {}", e));
+            CommandResult::error(format!("cd: {}\n", e))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn test_cd_to_temp() {
+        let temp = tempdir().unwrap();
+        let temp_path = temp.path().to_string_lossy().to_string();
+        let original_dir = env::current_dir().unwrap();
+
+        let ctx = CommandContext::new(vec![temp_path.clone()]);
+        let result = cd(ctx).await;
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "");
+
+        // Restore original directory
+        env::set_current_dir(original_dir).unwrap();
+    }
+
+    #[tokio::test]
+    async fn test_cd_to_nonexistent() {
+        let ctx = CommandContext::new(vec!["/nonexistent/path/12345".to_string()]);
+        let result = cd(ctx).await;
+        assert!(!result.is_success());
+    }
+}

package/rust/src/commands/cp.rs

@@ -0,0 +1,187 @@
+//! Virtual `cp` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{trace_lazy, CommandResult, VirtualUtils};
+use std::fs;
+use std::path::Path;
+
+/// Execute the cp command
+///
+/// Copies files and directories.
+pub async fn cp(ctx: CommandContext) -> CommandResult {
+    if ctx.args.len() < 2 {
+        return VirtualUtils::invalid_argument_error("cp", "missing file operand");
+    }
+
+    // Parse flags
+    let mut recursive = false;
+    let mut paths = Vec::new();
+
+    for arg in &ctx.args {
+        if arg == "-r" || arg == "-R" || arg == "--recursive" {
+            recursive = true;
+        } else if arg.starts_with('-') {
+            if arg.contains('r') || arg.contains('R') {
+                recursive = true;
+            }
+        } else {
+            paths.push(arg.clone());
+        }
+    }
+
+    if paths.len() < 2 {
+        return VirtualUtils::invalid_argument_error("cp", "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, copy 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!(
+            "cp: target '{}' is not a directory\n",
+            dest
+        ));
+    }
+
+    for source in paths {
+        let source_path = VirtualUtils::resolve_path(&source, Some(&cwd));
+
+        trace_lazy("VirtualCommand", || {
+            format!("cp: copying {:?} to {:?}", source_path, dest_path)
+        });
+
+        if !source_path.exists() {
+            return CommandResult::error(format!(
+                "cp: 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()
+        };
+
+        if source_path.is_dir() {
+            if !recursive {
+                return CommandResult::error(format!(
+                    "cp: -r not specified; omitting directory '{}'\n",
+                    source
+                ));
+            }
+
+            if let Err(e) = copy_dir_recursive(&source_path, &final_dest) {
+                return CommandResult::error(format!(
+                    "cp: cannot copy '{}': {}\n",
+                    source, e
+                ));
+            }
+        } else {
+            if let Some(parent) = final_dest.parent() {
+                if !parent.exists() {
+                    if let Err(e) = fs::create_dir_all(parent) {
+                        return CommandResult::error(format!(
+                            "cp: cannot create directory '{}': {}\n",
+                            parent.display(), e
+                        ));
+                    }
+                }
+            }
+
+            if let Err(e) = fs::copy(&source_path, &final_dest) {
+                return CommandResult::error(format!(
+                    "cp: cannot copy '{}': {}\n",
+                    source, e
+                ));
+            }
+        }
+    }
+
+    CommandResult::success_empty()
+}
+
+fn copy_dir_recursive(src: &Path, dst: &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_dir_recursive(&entry_path, &dest_path)?;
+        } else {
+            fs::copy(&entry_path, &dest_path)?;
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn test_cp_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 = cp(ctx).await;
+
+        assert!(result.is_success());
+        assert!(dst.exists());
+        assert_eq!(fs::read_to_string(&dst).unwrap(), "test content");
+    }
+
+    #[tokio::test]
+    async fn test_cp_directory_recursive() {
+        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![
+            "-r".to_string(),
+            src_dir.to_string_lossy().to_string(),
+            dst_dir.to_string_lossy().to_string(),
+        ]);
+        let result = cp(ctx).await;
+
+        assert!(result.is_success());
+        assert!(dst_dir.join("file.txt").exists());
+    }
+
+    #[tokio::test]
+    async fn test_cp_directory_without_recursive() {
+        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();
+
+        let ctx = CommandContext::new(vec![
+            src_dir.to_string_lossy().to_string(),
+            dst_dir.to_string_lossy().to_string(),
+        ]);
+        let result = cp(ctx).await;
+
+        assert!(!result.is_success());
+        assert!(result.stderr.contains("-r not specified"));
+    }
+}

package/rust/src/commands/dirname.rs

@@ -0,0 +1,57 @@
+//! Virtual `dirname` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::{CommandResult, VirtualUtils};
+use std::path::Path;
+
+/// Execute the dirname command
+///
+/// Strips the last component from filenames.
+pub async fn dirname(ctx: CommandContext) -> CommandResult {
+    if ctx.args.is_empty() {
+        return VirtualUtils::missing_operand_error("dirname");
+    }
+
+    let path = &ctx.args[0];
+    let parent = Path::new(path)
+        .parent()
+        .map(|p| p.to_string_lossy().to_string())
+        .unwrap_or_else(|| ".".to_string());
+
+    // Handle empty parent (file in current directory)
+    let result = if parent.is_empty() { "." } else { &parent };
+
+    CommandResult::success(format!("{}\n", result))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_dirname_simple() {
+        let ctx = CommandContext::new(vec!["/path/to/file.txt".to_string()]);
+        let result = dirname(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "/path/to\n");
+    }
+
+    #[tokio::test]
+    async fn test_dirname_just_file() {
+        let ctx = CommandContext::new(vec!["file.txt".to_string()]);
+        let result = dirname(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, ".\n");
+    }
+
+    #[tokio::test]
+    async fn test_dirname_root() {
+        let ctx = CommandContext::new(vec!["/file.txt".to_string()]);
+        let result = dirname(ctx).await;
+
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "/\n");
+    }
+}

package/rust/src/commands/echo.rs

@@ -0,0 +1,73 @@
+//! Virtual `echo` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::CommandResult;
+
+/// Execute the echo command
+///
+/// Outputs the arguments separated by spaces, followed by a newline.
+/// Supports -n (no newline), -e (interpret escape sequences), and -E (no escape sequences)
+pub async fn echo(ctx: CommandContext) -> CommandResult {
+    let mut no_newline = false;
+    let mut interpret_escapes = false;
+    let mut args = ctx.args.iter().peekable();
+
+    // Parse flags
+    while let Some(arg) = args.peek() {
+        if arg.starts_with('-') && arg.len() > 1 && arg.chars().skip(1).all(|c| c == 'n' || c == 'e' || c == 'E') {
+            let arg = args.next().unwrap();
+            for c in arg.chars().skip(1) {
+                match c {
+                    'n' => no_newline = true,
+                    'e' => interpret_escapes = true,
+                    'E' => interpret_escapes = false,
+                    _ => {}
+                }
+            }
+        } else {
+            break;
+        }
+    }
+
+    // Collect remaining args
+    let remaining: Vec<_> = args.collect();
+    let output = remaining.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(" ");
+
+    // Process escape sequences if -e flag is set
+    let output = if interpret_escapes {
+        output
+            .replace("\\n", "\n")
+            .replace("\\t", "\t")
+            .replace("\\r", "\r")
+            .replace("\\\\", "\\")
+    } else {
+        output
+    };
+
+    if no_newline {
+        CommandResult::success(output)
+    } else {
+        CommandResult::success(format!("{}\n", output))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_echo_simple() {
+        let ctx = CommandContext::new(vec!["hello".to_string(), "world".to_string()]);
+        let result = echo(ctx).await;
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "hello world\n");
+    }
+
+    #[tokio::test]
+    async fn test_echo_empty() {
+        let ctx = CommandContext::new(vec![]);
+        let result = echo(ctx).await;
+        assert!(result.is_success());
+        assert_eq!(result.stdout, "\n");
+    }
+}

package/rust/src/commands/env.rs

@@ -0,0 +1,33 @@
+//! Virtual `env` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::CommandResult;
+use std::env;
+
+/// Execute the env command
+///
+/// Displays environment variables.
+pub async fn env(_ctx: CommandContext) -> CommandResult {
+    let mut output = String::new();
+
+    for (key, value) in env::vars() {
+        output.push_str(&format!("{}={}\n", key, value));
+    }
+
+    CommandResult::success(output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_env() {
+        let ctx = CommandContext::new(vec![]);
+        let result = env(ctx).await;
+
+        assert!(result.is_success());
+        // Should contain at least PATH or HOME
+        assert!(result.stdout.contains("PATH=") || result.stdout.contains("HOME="));
+    }
+}

package/rust/src/commands/exit.rs

@@ -0,0 +1,36 @@
+//! Virtual `exit` command implementation
+
+use crate::commands::CommandContext;
+use crate::utils::CommandResult;
+
+/// Execute the exit command
+///
+/// Exits with the specified code (default 0).
+/// Note: This doesn't actually exit the process, it returns the exit code.
+pub async fn exit(ctx: CommandContext) -> CommandResult {
+    let code: i32 = ctx.args
+        .first()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(0);
+
+    CommandResult::error_with_code("", code)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_exit_default() {
+        let ctx = CommandContext::new(vec![]);
+        let result = exit(ctx).await;
+        assert_eq!(result.code, 0);
+    }
+
+    #[tokio::test]
+    async fn test_exit_with_code() {
+        let ctx = CommandContext::new(vec!["42".to_string()]);
+        let result = exit(ctx).await;
+        assert_eq!(result.code, 42);
+    }
+}