feat(vfs): add mkfifo and named pipe (FIFO) support (#591)

## Summary

- Add `FileType::Fifo` variant to VFS with full read/write/stat support
- Implement `mkfifo` builtin with `-m mode` flag and multiple path
support
- Update `test -p` / `[ -p ]` to detect FIFOs via metadata
- Update `file`, `stat`, `ls -l` to identify FIFOs (type `p`)
- FIFOs simulated as buffered files, preserving type across writes

## Test plan

- [x] 9 unit tests for mkfifo builtin (mode flags, errors, multiple
paths)
- [x] 15 integration tests (FIFO creation, test -p, file/stat,
read/write, type preservation)
- [x] `cargo fmt --check` passes
- [x] `cargo clippy --all-targets -- -D warnings` passes
- [x] `cargo test --all-features` passes (1939+ unit + integration
tests)

Closes #557

Author: chaliy

crates/bashkit-cli/src/mcp.rs

@@ -202,6 +202,7 @@ impl McpServer {
     }
 
     fn handle_tools_list(&self, id: serde_json::Value) -> JsonRpcResponse {
+        #[allow(unused_mut)]
         let mut tools = vec![McpTool {
             name: "bash".to_string(),
             description: "Execute a bash script in a virtual environment".to_string(),

crates/bashkit/src/builtins/inspect.rs

@@ -125,6 +125,7 @@ impl Builtin for File {
                         determine_file_content_type(&content)
                     }
                 }
+                FileType::Fifo => "fifo (named pipe)".to_string(),
             };
 
             output.push_str(&format!("{}: {}\n", file, file_type_str));
@@ -344,6 +345,7 @@ fn format_file_type(file_type: FileType) -> String {
         FileType::File => "regular file".to_string(),
         FileType::Directory => "directory".to_string(),
         FileType::Symlink => "symbolic link".to_string(),
+        FileType::Fifo => "fifo (named pipe)".to_string(),
     }
 }
 
@@ -352,6 +354,7 @@ fn format_permissions(metadata: &crate::fs::Metadata) -> String {
     let file_type = match metadata.file_type {
         FileType::Directory => 'd',
         FileType::Symlink => 'l',
+        FileType::Fifo => 'p',
         FileType::File => '-',
     };
 

crates/bashkit/src/builtins/ls.rs

@@ -226,6 +226,7 @@ fn format_long_entry(name: &str, metadata: &crate::fs::Metadata, human: bool) ->
     let file_type = match metadata.file_type {
         FileType::Directory => 'd',
         FileType::Symlink => 'l',
+        FileType::Fifo => 'p',
         FileType::File => '-',
     };
 

crates/bashkit/src/builtins/mkfifo.rs

@@ -0,0 +1,228 @@
+//! mkfifo builtin - create named pipes in the virtual filesystem.
+//!
+//! Creates FIFO entries in the VFS. `test -p` returns true for these.
+//! In VFS mode, data written/read behaves like a regular file buffer.
+
+use async_trait::async_trait;
+
+use super::{Builtin, Context, resolve_path};
+use crate::error::Result;
+use crate::interpreter::ExecResult;
+
+/// The mkfifo builtin - create named pipes.
+///
+/// Usage: mkfifo [-m MODE] NAME...
+///
+/// Creates FIFO entries at the given paths via `FileSystem::mkfifo`.
+/// The `-m` flag sets the permission mode (octal, default 0o666).
+pub struct Mkfifo;
+
+/// Parse an octal mode string (e.g. "0644", "755") to u32.
+/// Returns None if the string is not valid octal.
+fn parse_mode(s: &str) -> Option<u32> {
+    let trimmed = s.trim_start_matches('0');
+    let trimmed = if trimmed.is_empty() { "0" } else { trimmed };
+    u32::from_str_radix(trimmed, 8).ok()
+}
+
+#[async_trait]
+impl Builtin for Mkfifo {
+    async fn execute(&self, ctx: Context<'_>) -> Result<ExecResult> {
+        if ctx.args.is_empty() {
+            return Ok(ExecResult::err("mkfifo: missing operand\n".to_string(), 1));
+        }
+
+        // Parse arguments: extract -m mode, collect paths
+        let mut paths = Vec::new();
+        let mut mode: u32 = 0o666;
+        let mut i = 0;
+        while i < ctx.args.len() {
+            let arg = &ctx.args[i];
+            if arg == "-m" {
+                if i + 1 >= ctx.args.len() {
+                    return Ok(ExecResult::err(
+                        "mkfifo: option requires an argument -- 'm'\n".to_string(),
+                        1,
+                    ));
+                }
+                if let Some(m) = parse_mode(&ctx.args[i + 1]) {
+                    mode = m;
+                } else {
+                    return Ok(ExecResult::err(
+                        format!("mkfifo: invalid mode '{}'\n", ctx.args[i + 1]),
+                        1,
+                    ));
+                }
+                i += 2;
+            } else if let Some(mode_str) = arg.strip_prefix("-m") {
+                // -mMODE (combined form)
+                if let Some(m) = parse_mode(mode_str) {
+                    mode = m;
+                } else {
+                    return Ok(ExecResult::err(
+                        format!("mkfifo: invalid mode '{}'\n", mode_str),
+                        1,
+                    ));
+                }
+                i += 1;
+            } else if arg.starts_with('-') && arg != "-" {
+                return Ok(ExecResult::err(
+                    format!("mkfifo: invalid option -- '{}'\n", &arg[1..]),
+                    1,
+                ));
+            } else {
+                paths.push(arg.clone());
+                i += 1;
+            }
+        }
+
+        if paths.is_empty() {
+            return Ok(ExecResult::err("mkfifo: missing operand\n".to_string(), 1));
+        }
+
+        let mut stderr = String::new();
+        let mut failed = false;
+
+        for name in &paths {
+            let path = resolve_path(ctx.cwd, name);
+
+            if let Err(e) = ctx.fs.mkfifo(&path, mode).await {
+                let msg = e.to_string();
+                // Map error messages to mkfifo-style output
+                if msg.contains("lready") || msg.contains("exists") {
+                    stderr.push_str(&format!(
+                        "mkfifo: cannot create fifo '{}': File exists\n",
+                        name
+                    ));
+                } else if msg.contains("ot found") || msg.contains("o such") {
+                    stderr.push_str(&format!(
+                        "mkfifo: cannot create fifo '{}': No such file or directory\n",
+                        name
+                    ));
+                } else {
+                    stderr.push_str(&format!("mkfifo: cannot create fifo '{}': {}\n", name, e));
+                }
+                failed = true;
+            }
+        }
+
+        if failed {
+            Ok(ExecResult::err(stderr, 1))
+        } else {
+            Ok(ExecResult::ok(String::new()))
+        }
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+    use super::*;
+    use crate::fs::{FileSystem, InMemoryFs};
+    use std::collections::HashMap;
+    use std::path::{Path, PathBuf};
+    use std::sync::Arc;
+
+    async fn run_mkfifo(args: &[&str]) -> ExecResult {
+        let args: Vec<String> = args.iter().map(|s| s.to_string()).collect();
+        let env = HashMap::new();
+        let mut variables = HashMap::new();
+        let mut cwd = PathBuf::from("/");
+        let fs = Arc::new(InMemoryFs::new());
+
+        let ctx = Context::new_for_test(&args, &env, &mut variables, &mut cwd, fs, None);
+        Mkfifo.execute(ctx).await.unwrap()
+    }
+
+    async fn run_mkfifo_with_fs(args: &[&str], fs: Arc<InMemoryFs>) -> ExecResult {
+        let args: Vec<String> = args.iter().map(|s| s.to_string()).collect();
+        let env = HashMap::new();
+        let mut variables = HashMap::new();
+        let mut cwd = PathBuf::from("/");
+
+        let ctx = Context::new_for_test(&args, &env, &mut variables, &mut cwd, fs, None);
+        Mkfifo.execute(ctx).await.unwrap()
+    }
+
+    #[tokio::test]
+    async fn mkfifo_creates_fifo() {
+        let fs = Arc::new(InMemoryFs::new());
+        let result = run_mkfifo_with_fs(&["mypipe"], fs.clone()).await;
+        assert_eq!(result.exit_code, 0);
+        assert!(fs.exists(Path::new("/mypipe")).await.unwrap());
+        // Verify it's a FIFO
+        let meta = fs.stat(Path::new("/mypipe")).await.unwrap();
+        assert!(meta.file_type.is_fifo());
+    }
+
+    #[tokio::test]
+    async fn mkfifo_multiple_paths() {
+        let fs = Arc::new(InMemoryFs::new());
+        let result = run_mkfifo_with_fs(&["pipe1", "pipe2", "pipe3"], fs.clone()).await;
+        assert_eq!(result.exit_code, 0);
+        assert!(fs.exists(Path::new("/pipe1")).await.unwrap());
+        assert!(fs.exists(Path::new("/pipe2")).await.unwrap());
+        assert!(fs.exists(Path::new("/pipe3")).await.unwrap());
+    }
+
+    #[tokio::test]
+    async fn mkfifo_existing_file_error() {
+        let fs = Arc::new(InMemoryFs::new());
+        fs.write_file(Path::new("/existing"), b"data")
+            .await
+            .unwrap();
+
+        let result = run_mkfifo_with_fs(&["existing"], fs).await;
+        assert_eq!(result.exit_code, 1);
+        assert!(result.stderr.contains("File exists"));
+    }
+
+    #[tokio::test]
+    async fn mkfifo_missing_operand() {
+        let result = run_mkfifo(&[]).await;
+        assert_eq!(result.exit_code, 1);
+        assert!(result.stderr.contains("missing operand"));
+    }
+
+    #[tokio::test]
+    async fn mkfifo_mode_flag_accepted() {
+        let fs = Arc::new(InMemoryFs::new());
+        let result = run_mkfifo_with_fs(&["-m", "0644", "mypipe"], fs.clone()).await;
+        assert_eq!(result.exit_code, 0);
+        let meta = fs.stat(Path::new("/mypipe")).await.unwrap();
+        assert_eq!(meta.mode, 0o644);
+    }
+
+    #[tokio::test]
+    async fn mkfifo_mode_flag_combined() {
+        let fs = Arc::new(InMemoryFs::new());
+        let result = run_mkfifo_with_fs(&["-m0755", "mypipe"], fs.clone()).await;
+        assert_eq!(result.exit_code, 0);
+        let meta = fs.stat(Path::new("/mypipe")).await.unwrap();
+        assert_eq!(meta.mode, 0o755);
+    }
+
+    #[tokio::test]
+    async fn mkfifo_mode_missing_arg() {
+        let result = run_mkfifo(&["-m"]).await;
+        assert_eq!(result.exit_code, 1);
+        assert!(result.stderr.contains("option requires an argument"));
+    }
+
+    #[tokio::test]
+    async fn mkfifo_nonexistent_parent() {
+        let fs = Arc::new(InMemoryFs::new());
+        let result = run_mkfifo_with_fs(&["/no/such/dir/pipe"], fs).await;
+        assert_eq!(result.exit_code, 1);
+        assert!(result.stderr.contains("No such file or directory"));
+    }
+
+    #[tokio::test]
+    async fn mkfifo_default_mode() {
+        let fs = Arc::new(InMemoryFs::new());
+        let result = run_mkfifo_with_fs(&["mypipe"], fs.clone()).await;
+        assert_eq!(result.exit_code, 0);
+        let meta = fs.stat(Path::new("/mypipe")).await.unwrap();
+        assert_eq!(meta.mode, 0o666);
+    }
+}

crates/bashkit/src/builtins/mod.rs

@@ -64,6 +64,7 @@ mod jq;
 mod json;
 mod log;
 mod ls;
+mod mkfifo;
 mod navigation;
 mod nl;
 mod parallel;
@@ -147,6 +148,7 @@ pub use json::Json;
 pub use log::Log;
 pub(crate) use ls::glob_match;
 pub use ls::{Find, Ls, Rmdir};
+pub use mkfifo::Mkfifo;
 pub use navigation::{Cd, Pwd};
 pub use nl::Nl;
 pub use parallel::Parallel;

crates/bashkit/src/builtins/test.rs

@@ -200,7 +200,15 @@ async fn evaluate_unary(op: &str, arg: &str, fs: &Arc<dyn FileSystem>, cwd: &Pat
                 false
             }
         }
-        "-p" => false, // named pipe (not supported)
+        "-p" => {
+            // named pipe (FIFO)
+            let path = resolve_file_path(cwd, arg);
+            if let Ok(meta) = fs.stat(&path).await {
+                meta.file_type.is_fifo()
+            } else {
+                false
+            }
+        }
         "-S" => false, // socket (not supported)
         "-b" => false, // block device (not supported)
         "-c" => false, // character device (not supported)