bump to 0.66 (#6137)

* Allow multiple patterns in ls command

* Run formatter

* Comply with style

* Fix format error

.github/workflows/ci.yml

@@ -135,10 +135,7 @@ jobs:
       - run: python -m pip install tox
 
       - name: Install virtualenv
-        run: |
-          git clone https://github.com/kubouch/virtualenv.git && \
-          cd virtualenv && \
-          git checkout engine-q-update
+        run: git clone https://github.com/pypa/virtualenv.git          
         shell: bash
 
       - name: Test Nushell in virtualenv

Cargo.toml

@@ -11,7 +11,7 @@ name = "nu"
 readme = "README.md"
 repository = "https://github.com/nushell/nushell"
 rust-version = "1.60"
-version = "0.65.0"
+version = "0.66.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -28,6 +28,7 @@ members = [
 	"crates/nu_plugin_gstat",
 	"crates/nu_plugin_example",
 	"crates/nu_plugin_query",
+	"crates/nu_plugin_custom_values",
 	"crates/nu-utils",
 ]
 
@@ -38,21 +39,21 @@ ctrlc = "3.2.1"
 log = "0.4"
 miette = "5.1.0"
 nu-ansi-term = "0.46.0"
-nu-cli = { path="./crates/nu-cli", version = "0.65.0"  }
-nu-color-config = { path = "./crates/nu-color-config", version = "0.65.0"  }
-nu-command = { path="./crates/nu-command", version = "0.65.0"  }
-nu-engine = { path="./crates/nu-engine", version = "0.65.0"  }
-nu-json = { path="./crates/nu-json", version = "0.65.0"  }
-nu-parser = { path="./crates/nu-parser", version = "0.65.0"  }
-nu-path = { path="./crates/nu-path", version = "0.65.0"  }
-nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.65.0"  }
-nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.65.0"  }
-nu-protocol = { path = "./crates/nu-protocol", version = "0.65.0"  }
-nu-system = { path = "./crates/nu-system", version = "0.65.0" }
-nu-table = { path = "./crates/nu-table", version = "0.65.0"  }
-nu-term-grid = { path = "./crates/nu-term-grid", version = "0.65.0"  }
-nu-utils = { path = "./crates/nu-utils", version = "0.65.0"  }
-reedline = { version = "0.8.0", features = ["bashisms", "sqlite"]}
+nu-cli = { path="./crates/nu-cli", version = "0.66.0"  }
+nu-color-config = { path = "./crates/nu-color-config", version = "0.66.0"  }
+nu-command = { path="./crates/nu-command", version = "0.66.0"  }
+nu-engine = { path="./crates/nu-engine", version = "0.66.0"  }
+nu-json = { path="./crates/nu-json", version = "0.66.0"  }
+nu-parser = { path="./crates/nu-parser", version = "0.66.0"  }
+nu-path = { path="./crates/nu-path", version = "0.66.0"  }
+nu-plugin = { path = "./crates/nu-plugin", optional = true, version = "0.66.0"  }
+nu-pretty-hex = { path = "./crates/nu-pretty-hex", version = "0.66.0"  }
+nu-protocol = { path = "./crates/nu-protocol", version = "0.66.0"  }
+nu-system = { path = "./crates/nu-system", version = "0.66.0" }
+nu-table = { path = "./crates/nu-table", version = "0.66.0"  }
+nu-term-grid = { path = "./crates/nu-term-grid", version = "0.66.0"  }
+nu-utils = { path = "./crates/nu-utils", version = "0.66.0"  }
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
 pretty_env_logger = "0.4.0"
 rayon = "1.5.1"
 is_executable = "1.0.1"
@@ -63,13 +64,13 @@ openssl = { version = "0.10.38", features = ["vendored"], optional = true }
 signal-hook = { version = "0.3.14", default-features = false }
 
 [dev-dependencies]
-nu-test-support = { path="./crates/nu-test-support", version = "0.65.0"  }
+nu-test-support = { path="./crates/nu-test-support", version = "0.66.0"  }
 tempfile = "3.2.0"
 assert_cmd = "2.0.2"
 pretty_assertions = "1.0.0"
-serial_test = "0.5.1"
+serial_test = "0.8.0"
 hamcrest2 = "0.3.0"
-rstest = "0.12.0"
+rstest = "0.15.0"
 itertools = "0.10.3"
 
 [target.'cfg(windows)'.build-dependencies]

crates/nu-cli/Cargo.toml

@@ -4,29 +4,32 @@ description = "CLI-related functionality for Nushell"
 edition = "2021"
 license = "MIT"
 name = "nu-cli"
-version = "0.65.0"
+version = "0.66.0"
 
 [dev-dependencies]
-nu-test-support = { path="../nu-test-support", version = "0.65.0"  }
-nu-command = { path = "../nu-command", version = "0.65.0" }
+nu-test-support = { path="../nu-test-support", version = "0.66.0"  }
+nu-command = { path = "../nu-command", version = "0.66.0" }
+rstest = "0.15.0"
 
 [dependencies]
-nu-engine = { path = "../nu-engine", version = "0.65.0"  }
-nu-path = { path = "../nu-path", version = "0.65.0"  }
-nu-parser = { path = "../nu-parser", version = "0.65.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.65.0"  }
-nu-utils = { path = "../nu-utils", version = "0.65.0"  }
+nu-engine = { path = "../nu-engine", version = "0.66.0"  }
+nu-path = { path = "../nu-path", version = "0.66.0"  }
+nu-parser = { path = "../nu-parser", version = "0.66.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.0"  }
+nu-utils = { path = "../nu-utils", version = "0.66.0"  }
 nu-ansi-term = "0.46.0"
-nu-color-config = { path = "../nu-color-config", version = "0.65.0"  }
-reedline = { version = "0.8.0", features = ["bashisms", "sqlite"]}
+nu-color-config = { path = "../nu-color-config", version = "0.66.0"  }
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
 crossterm = "0.23.0"
 miette = { version = "5.1.0", features = ["fancy"] }
 thiserror = "1.0.31"
 fuzzy-matcher = "0.3.7"
 
-log = "0.4"
-is_executable = "1.0.1"
 chrono = "0.4.19"
+is_executable = "1.0.1"
+lazy_static = "1.4.0"
+log = "0.4"
+regex = "1.5.4"
 sysinfo = "0.24.1"
 
 [features]

crates/nu-cli/src/commands.rs

@@ -5,21 +5,27 @@ use nu_engine::{convert_env_values, eval_block};
 use nu_parser::parse;
 use nu_protocol::engine::Stack;
 use nu_protocol::{
-    engine::{EngineState, StateDelta, StateWorkingSet},
+    engine::{EngineState, StateWorkingSet},
     PipelineData, Spanned, Value,
 };
-use std::path::Path;
 
+/// Run a command (or commands) given to us by the user
 pub fn evaluate_commands(
     commands: &Spanned<String>,
-    init_cwd: &Path,
     engine_state: &mut EngineState,
     stack: &mut Stack,
     input: PipelineData,
     is_perf_true: bool,
     table_mode: Option<Value>,
 ) -> Result<Option<i64>> {
-    // Run a command (or commands) given to us by the user
+    // Translate environment variables from Strings to Values
+    if let Some(e) = convert_env_values(engine_state, stack) {
+        let working_set = StateWorkingSet::new(engine_state);
+        report_error(&working_set, &e);
+        std::process::exit(1);
+    }
+
+    // Parse the source code
     let (block, delta) = {
         if let Some(ref t_mode) = table_mode {
             let mut config = engine_state.get_config().clone();
@@ -39,43 +45,19 @@ pub fn evaluate_commands(
         (output, working_set.render())
     };
 
-    if let Err(err) = engine_state.merge_delta(delta, None, init_cwd) {
+    // Update permanent state
+    if let Err(err) = engine_state.merge_delta(delta) {
         let working_set = StateWorkingSet::new(engine_state);
         report_error(&working_set, &err);
     }
 
-    let mut config = engine_state.get_config().clone();
-    if let Some(t_mode) = table_mode {
-        config.table_mode = t_mode.as_string()?;
-    }
-
-    // Merge the delta in case env vars changed in the config
-    match nu_engine::env::current_dir(engine_state, stack) {
-        Ok(cwd) => {
-            if let Err(e) =
-                engine_state.merge_delta(StateDelta::new(engine_state), Some(stack), cwd)
-            {
-                let working_set = StateWorkingSet::new(engine_state);
-                report_error(&working_set, &e);
-                std::process::exit(1);
-            }
-        }
-        Err(e) => {
-            let working_set = StateWorkingSet::new(engine_state);
-            report_error(&working_set, &e);
-            std::process::exit(1);
-        }
-    }
-
-    // Translate environment variables from Strings to Values
-    if let Some(e) = convert_env_values(engine_state, stack) {
-        let working_set = StateWorkingSet::new(engine_state);
-        report_error(&working_set, &e);
-        std::process::exit(1);
-    }
-
+    // Run the block
     let exit_code = match eval_block(engine_state, stack, &block, input, false, false) {
         Ok(pipeline_data) => {
+            let mut config = engine_state.get_config().clone();
+            if let Some(t_mode) = table_mode {
+                config.table_mode = t_mode.as_string()?;
+            }
             crate::eval_file::print_table_or_error(engine_state, stack, pipeline_data, &mut config)
         }
         Err(err) => {

crates/nu-cli/src/completions/command_completions.rs

@@ -43,19 +43,21 @@ impl CommandCompletion {
 
                     if let Ok(mut contents) = std::fs::read_dir(path) {
                         while let Some(Ok(item)) = contents.next() {
-                            if !executables.contains(
-                                &item
-                                    .path()
-                                    .file_name()
-                                    .map(|x| x.to_string_lossy().to_string())
-                                    .unwrap_or_default(),
-                            ) && matches!(
-                                item.path()
-                                    .file_name()
-                                    .map(|x| match_algorithm
+                            if self.engine_state.config.max_external_completion_results
+                                > executables.len() as i64
+                                && !executables.contains(
+                                    &item
+                                        .path()
+                                        .file_name()
+                                        .map(|x| x.to_string_lossy().to_string())
+                                        .unwrap_or_default(),
+                                )
+                                && matches!(
+                                    item.path().file_name().map(|x| match_algorithm
                                         .matches_str(&x.to_string_lossy(), prefix)),
-                                Some(true)
-                            ) && is_executable::is_executable(&item.path())
+                                    Some(true)
+                                )
+                                && is_executable::is_executable(&item.path())
                             {
                                 if let Ok(name) = item.file_name().into_string() {
                                     executables.push(name);

crates/nu-cli/src/config_files.rs

@@ -1,7 +1,13 @@
 use crate::util::{eval_source, report_error};
 #[cfg(feature = "plugin")]
 use log::info;
-use nu_protocol::engine::{EngineState, Stack, StateDelta, StateWorkingSet};
+#[cfg(feature = "plugin")]
+use nu_parser::ParseError;
+#[cfg(feature = "plugin")]
+use nu_path::canonicalize_with;
+use nu_protocol::engine::{EngineState, Stack, StateWorkingSet};
+#[cfg(feature = "plugin")]
+use nu_protocol::Spanned;
 use nu_protocol::{HistoryFileFormat, PipelineData, Span};
 use std::path::PathBuf;
 
@@ -15,12 +21,13 @@ const HISTORY_FILE_SQLITE: &str = "history.sqlite3";
 pub fn read_plugin_file(
     engine_state: &mut EngineState,
     stack: &mut Stack,
+    plugin_file: Option<Spanned<String>>,
     storage_path: &str,
     is_perf_true: bool,
 ) {
     // Reading signatures from signature file
     // The plugin.nu file stores the parsed signature collected from each registered plugin
-    add_plugin_file(engine_state, storage_path);
+    add_plugin_file(engine_state, plugin_file, storage_path);
 
     let plugin_path = engine_state.plugin_signatures.clone();
     if let Some(plugin_path) = plugin_path {
@@ -43,8 +50,23 @@ pub fn read_plugin_file(
 }
 
 #[cfg(feature = "plugin")]
-pub fn add_plugin_file(engine_state: &mut EngineState, storage_path: &str) {
-    if let Some(mut plugin_path) = nu_path::config_dir() {
+pub fn add_plugin_file(
+    engine_state: &mut EngineState,
+    plugin_file: Option<Spanned<String>>,
+    storage_path: &str,
+) {
+    if let Some(plugin_file) = plugin_file {
+        let working_set = StateWorkingSet::new(engine_state);
+        let cwd = working_set.get_cwd();
+
+        match canonicalize_with(&plugin_file.item, cwd) {
+            Ok(path) => engine_state.plugin_signatures = Some(path),
+            Err(_) => {
+                let e = ParseError::FileNotFound(plugin_file.item, plugin_file.span);
+                report_error(&working_set, &e);
+            }
+        }
+    } else if let Some(mut plugin_path) = nu_path::config_dir() {
         // Path to store plugins signatures
         plugin_path.push(storage_path);
         plugin_path.push(PLUGIN_FILE);
@@ -69,12 +91,10 @@ pub fn eval_config_contents(
                 PipelineData::new(Span::new(0, 0)),
             );
 
-            // Merge the delta in case env vars changed in the config
+            // Merge the environment in case env vars changed in the config
             match nu_engine::env::current_dir(engine_state, stack) {
                 Ok(cwd) => {
-                    if let Err(e) =
-                        engine_state.merge_delta(StateDelta::new(engine_state), Some(stack), cwd)
-                    {
+                    if let Err(e) = engine_state.merge_env(stack, cwd) {
                         let working_set = StateWorkingSet::new(engine_state);
                         report_error(&working_set, &e);
                     }

crates/nu-cli/src/eval_file.rs

@@ -77,54 +77,33 @@ pub fn print_table_or_error(
 
     match engine_state.find_decl("table".as_bytes(), &[]) {
         Some(decl_id) => {
-            let table = engine_state.get_decl(decl_id).run(
-                engine_state,
-                stack,
-                &Call::new(Span::new(0, 0)),
-                pipeline_data,
-            );
+            let command = engine_state.get_decl(decl_id);
+            if command.get_block_id().is_some() {
+                print_or_exit(pipeline_data, engine_state, config);
+            } else {
+                let table = command.run(
+                    engine_state,
+                    stack,
+                    &Call::new(Span::new(0, 0)),
+                    pipeline_data,
+                );
 
-            match table {
-                Ok(table) => {
-                    for item in table {
-                        if let Value::Error { error } = item {
-                            let working_set = StateWorkingSet::new(engine_state);
-
-                            report_error(&working_set, &error);
-
-                            std::process::exit(1);
-                        }
-
-                        let mut out = item.into_string("\n", config);
-                        out.push('\n');
-
-                        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
+                match table {
+                    Ok(table) => {
+                        print_or_exit(table, engine_state, config);
                     }
-                }
-                Err(error) => {
-                    let working_set = StateWorkingSet::new(engine_state);
+                    Err(error) => {
+                        let working_set = StateWorkingSet::new(engine_state);
 
-                    report_error(&working_set, &error);
+                        report_error(&working_set, &error);
 
-                    std::process::exit(1);
+                        std::process::exit(1);
+                    }
                 }
             }
         }
         None => {
-            for item in pipeline_data {
-                if let Value::Error { error } = item {
-                    let working_set = StateWorkingSet::new(engine_state);
-
-                    report_error(&working_set, &error);
-
-                    std::process::exit(1);
-                }
-
-                let mut out = item.into_string("\n", config);
-                out.push('\n');
-
-                let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
-            }
+            print_or_exit(pipeline_data, engine_state, config);
         }
     };
 
@@ -141,3 +120,20 @@ pub fn print_table_or_error(
         None
     }
 }
+
+fn print_or_exit(pipeline_data: PipelineData, engine_state: &mut EngineState, config: &Config) {
+    for item in pipeline_data {
+        if let Value::Error { error } = item {
+            let working_set = StateWorkingSet::new(engine_state);
+
+            report_error(&working_set, &error);
+
+            std::process::exit(1);
+        }
+
+        let mut out = item.into_string("\n", config);
+        out.push('\n');
+
+        let _ = stdout_write_all_and_flush(out).map_err(|err| eprintln!("{}", err));
+    }
+}

crates/nu-cli/src/lib.rs

@@ -22,8 +22,9 @@ pub use nu_highlight::NuHighlight;
 pub use print::Print;
 pub use prompt::NushellPrompt;
 pub use repl::evaluate_repl;
+pub use repl::{eval_env_change_hook, eval_hook};
 pub use syntax_highlight::NuHighlighter;
-pub use util::{eval_source, gather_parent_env_vars, get_init_cwd, report_error};
+pub use util::{eval_source, gather_parent_env_vars, get_init_cwd, report_error, report_error_new};
 pub use validation::NuValidator;
 
 #[cfg(feature = "plugin")]

crates/nu-cli/src/prompt.rs

@@ -1,5 +1,6 @@
+#[cfg(windows)]
+use nu_utils::enable_vt_processing;
 use reedline::DefaultPrompt;
-
 use {
     reedline::{
         Prompt, PromptEditMode, PromptHistorySearch, PromptHistorySearchStatus, PromptViMode,
@@ -86,6 +87,11 @@ impl NushellPrompt {
 
 impl Prompt for NushellPrompt {
     fn render_prompt_left(&self) -> Cow<str> {
+        #[cfg(windows)]
+        {
+            let _ = enable_vt_processing();
+        }
+
         if let Some(prompt_string) = &self.left_prompt_string {
             prompt_string.replace('\n', "\r\n").into()
         } else {

crates/nu-cli/src/prompt_update.rs

@@ -15,6 +15,10 @@ pub(crate) const PROMPT_INDICATOR: &str = "PROMPT_INDICATOR";
 pub(crate) const PROMPT_INDICATOR_VI_INSERT: &str = "PROMPT_INDICATOR_VI_INSERT";
 pub(crate) const PROMPT_INDICATOR_VI_NORMAL: &str = "PROMPT_INDICATOR_VI_NORMAL";
 pub(crate) const PROMPT_MULTILINE_INDICATOR: &str = "PROMPT_MULTILINE_INDICATOR";
+// According to Daniel Imms @Tyriar, we need to do these this way:
+// <133 A><prompt><133 B><command><133 C><command output>
+const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
+const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
 
 fn get_prompt_string(
     prompt: &str,
@@ -98,6 +102,20 @@ pub(crate) fn update_prompt<'prompt>(
         is_perf_true,
     );
 
+    // Now that we have the prompt string lets ansify it.
+    // <133 A><prompt><133 B><command><133 C><command output>
+    let left_prompt_string = if config.shell_integration {
+        match left_prompt_string {
+            Some(prompt_string) => Some(format!(
+                "{}{}{}",
+                PRE_PROMPT_MARKER, prompt_string, POST_PROMPT_MARKER
+            )),
+            None => left_prompt_string,
+        }
+    } else {
+        left_prompt_string
+    };
+
     let right_prompt_string = get_prompt_string(
         PROMPT_COMMAND_RIGHT,
         config,

crates/nu-cli/src/repl.rs

@@ -2,26 +2,34 @@ use crate::{
     completions::NuCompleter,
     prompt_update,
     reedline_config::{add_menus, create_keybindings, KeybindingsMode},
-    util::{eval_source, report_error},
+    util::{eval_source, get_guaranteed_cwd, report_error, report_error_new},
     NuHighlighter, NuValidator, NushellPrompt,
 };
-use log::{info, trace};
+use lazy_static::lazy_static;
+use log::{info, trace, warn};
 use miette::{IntoDiagnostic, Result};
 use nu_color_config::get_color_config;
 use nu_engine::{convert_env_values, eval_block};
-use nu_parser::lex;
+use nu_parser::{lex, parse};
 use nu_protocol::{
+    ast::PathMember,
     engine::{EngineState, Stack, StateWorkingSet},
-    BlockId, HistoryFileFormat, PipelineData, PositionalArg, ShellError, Span, Value,
+    BlockId, HistoryFileFormat, PipelineData, PositionalArg, ShellError, Span, Type, Value, VarId,
 };
 use reedline::{DefaultHinter, Emacs, SqliteBackedHistory, Vi};
+use regex::Regex;
 use std::io::{self, Write};
 use std::{sync::atomic::Ordering, time::Instant};
 use sysinfo::SystemExt;
 
-const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
+// According to Daniel Imms @Tyriar, we need to do these this way:
+// <133 A><prompt><133 B><command><133 C><command output>
+// These first two have been moved to prompt_update to get as close as possible to the prompt.
+// const PRE_PROMPT_MARKER: &str = "\x1b]133;A\x1b\\";
+// const POST_PROMPT_MARKER: &str = "\x1b]133;B\x1b\\";
 const PRE_EXECUTE_MARKER: &str = "\x1b]133;C\x1b\\";
-const CMD_FINISHED_MARKER: &str = "\x1b]133;D\x1b\\";
+// This one is in get_command_finished_marker() now so we can capture the exit codes properly.
+// const CMD_FINISHED_MARKER: &str = "\x1b]133;D;{}\x1b\\";
 const RESET_APPLICATION_MODE: &str = "\x1b[?1l";
 
 pub fn evaluate_repl(
@@ -79,7 +87,7 @@ pub fn evaluate_repl(
 
     // Get the config once for the history `max_history_size`
     // Updating that will not be possible in one session
-    let mut config = engine_state.get_config();
+    let config = engine_state.get_config();
 
     if is_perf_true {
         info!("setup reedline {}:{}:{}", file!(), line!(), column!());
@@ -121,6 +129,14 @@ pub fn evaluate_repl(
             );
         }
 
+        let cwd = get_guaranteed_cwd(engine_state, stack);
+
+        // Before doing anything, merge the environment from the previous REPL iteration into the
+        // permanent state.
+        if let Err(err) = engine_state.merge_env(stack, cwd) {
+            report_error_new(engine_state, &err);
+        }
+
         //Reset the ctrl-c handler
         if let Some(ctrlc) = &mut engine_state.ctrlc {
             ctrlc.store(false, Ordering::SeqCst);
@@ -130,7 +146,7 @@ pub fn evaluate_repl(
             sig_quit.store(false, Ordering::SeqCst);
         }
 
-        config = engine_state.get_config();
+        let config = engine_state.get_config();
 
         if is_perf_true {
             info!("setup colors {}:{}:{}", file!(), line!(), column!());
@@ -147,7 +163,6 @@ pub fn evaluate_repl(
                 engine_state: engine_state.clone(),
                 config: config.clone(),
             }))
-            .with_animation(config.animate_prompt)
             .with_validator(Box::new(NuValidator {
                 engine_state: engine_state.clone(),
             }))
@@ -201,7 +216,10 @@ pub fn evaluate_repl(
             if is_perf_true {
                 info!("sync history {}:{}:{}", file!(), line!(), column!());
             }
-            line_editor.sync_history().into_diagnostic()?;
+
+            if let Err(e) = line_editor.sync_history() {
+                warn!("Failed to sync history: {}", e);
+            }
         }
 
         if is_perf_true {
@@ -236,64 +254,22 @@ pub fn evaluate_repl(
 
         // Right before we start our prompt and take input from the user,
         // fire the "pre_prompt" hook
-        if let Some(hook) = &config.hooks.pre_prompt {
-            if let Err(err) = run_hook(engine_state, stack, vec![], hook) {
-                let working_set = StateWorkingSet::new(engine_state);
-                report_error(&working_set, &err);
+        if let Some(hook) = config.hooks.pre_prompt.clone() {
+            if let Err(err) = eval_hook(engine_state, stack, vec![], &hook) {
+                report_error_new(engine_state, &err);
             }
         }
 
         // Next, check all the environment variables they ask for
         // fire the "env_change" hook
-        if let Some(hook) = config.hooks.env_change.clone() {
-            match hook {
-                Value::Record {
-                    cols, vals: blocks, ..
-                } => {
-                    for (idx, env_var) in cols.iter().enumerate() {
-                        let before = engine_state
-                            .previous_env_vars
-                            .get(env_var)
-                            .cloned()
-                            .unwrap_or_default();
-                        let after = stack.get_env_var(engine_state, env_var).unwrap_or_default();
-                        if before != after {
-                            if let Err(err) = run_hook(
-                                engine_state,
-                                stack,
-                                vec![before, after.clone()],
-                                &blocks[idx],
-                            ) {
-                                let working_set = StateWorkingSet::new(engine_state);
-                                report_error(&working_set, &err);
-                            }
-
-                            engine_state
-                                .previous_env_vars
-                                .insert(env_var.to_string(), after);
-                        }
-                    }
-                }
-                x => {
-                    let working_set = StateWorkingSet::new(engine_state);
-                    report_error(
-                        &working_set,
-                        &ShellError::TypeMismatch(
-                            "record for 'env_change' hook".to_string(),
-                            x.span().unwrap_or_else(|_| Span::new(0, 0)),
-                        ),
-                    )
-                }
-            }
-        }
-
-        config = engine_state.get_config();
-
-        let shell_integration = config.shell_integration;
-        if shell_integration {
-            run_ansi_sequence(PRE_PROMPT_MARKER)?;
+        let config = engine_state.get_config();
+        if let Err(error) =
+            eval_env_change_hook(config.hooks.env_change.clone(), engine_state, stack)
+        {
+            report_error_new(engine_state, &error)
         }
 
+        let config = engine_state.get_config();
         let prompt =
             prompt_update::update_prompt(config, engine_state, stack, &mut nu_prompt, is_perf_true);
 
@@ -309,6 +285,7 @@ pub fn evaluate_repl(
         }
 
         let input = line_editor.read_line(prompt);
+        let shell_integration = config.shell_integration;
 
         match input {
             Ok(Signal::Success(s)) => {
@@ -328,32 +305,31 @@ pub fn evaluate_repl(
 
                 // Right before we start running the code the user gave us,
                 // fire the "pre_execution" hook
-                if let Some(hook) = &config.hooks.pre_execution {
-                    if let Err(err) = run_hook(engine_state, stack, vec![], hook) {
-                        let working_set = StateWorkingSet::new(engine_state);
-                        report_error(&working_set, &err);
+                if let Some(hook) = config.hooks.pre_execution.clone() {
+                    if let Err(err) = eval_hook(engine_state, stack, vec![], &hook) {
+                        report_error_new(engine_state, &err);
                     }
                 }
 
                 if shell_integration {
                     run_ansi_sequence(RESET_APPLICATION_MODE)?;
                     run_ansi_sequence(PRE_EXECUTE_MARKER)?;
-                    if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
-                        let path = cwd.as_string()?;
-                        // Try to abbreviate string for windows title
-                        let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
-                            path.replace(&p.as_path().display().to_string(), "~")
-                        } else {
-                            path
-                        };
+                    // if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+                    //     let path = cwd.as_string()?;
+                    //     // Try to abbreviate string for windows title
+                    //     let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
+                    //         path.replace(&p.as_path().display().to_string(), "~")
+                    //     } else {
+                    //         path
+                    //     };
 
-                        // Set window title too
-                        // https://tldp.org/HOWTO/Xterm-Title-3.html
-                        // ESC]0;stringBEL -- Set icon name and window title to string
-                        // ESC]1;stringBEL -- Set icon name to string
-                        // ESC]2;stringBEL -- Set window title to string
-                        run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?;
-                    }
+                    //     // Set window title too
+                    //     // https://tldp.org/HOWTO/Xterm-Title-3.html
+                    //     // ESC]0;stringBEL -- Set icon name and window title to string
+                    //     // ESC]1;stringBEL -- Set icon name to string
+                    //     // ESC]2;stringBEL -- Set window title to string
+                    //     run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?;
+                    // }
                 }
 
                 let start_time = Instant::now();
@@ -364,13 +340,7 @@ pub fn evaluate_repl(
 
                 let orig = s.clone();
 
-                if (orig.starts_with('.')
-                    || orig.starts_with('~')
-                    || orig.starts_with('/')
-                    || orig.starts_with('\\'))
-                    && path.is_dir()
-                    && tokens.0.len() == 1
-                {
+                if looks_like_path(&orig) && path.is_dir() && tokens.0.len() == 1 {
                     // We have an auto-cd
                     let (path, span) = {
                         if !path.exists() {
@@ -386,6 +356,14 @@ pub fn evaluate_repl(
                         (path.to_string_lossy().to_string(), tokens.0[0].span)
                     };
 
+                    stack.add_env_var(
+                        "OLDPWD".into(),
+                        Value::String {
+                            val: cwd.clone(),
+                            span: Span { start: 0, end: 0 },
+                        },
+                    );
+
                     //FIXME: this only changes the current scope, but instead this environment variable
                     //should probably be a block that loads the information from the state in the overlay
                     stack.add_env_var(
@@ -437,14 +415,6 @@ pub fn evaluate_repl(
                     },
                 );
 
-                // FIXME: permanent state changes like this hopefully in time can be removed
-                // and be replaced by just passing the cwd in where needed
-                if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
-                    let path = cwd.as_string()?;
-                    let _ = std::env::set_current_dir(path);
-                    engine_state.add_env_var("PWD".into(), cwd);
-                }
-
                 if history_supports_meta && !s.is_empty() {
                     line_editor
                         .update_last_command_context(&|mut c| {
@@ -458,20 +428,35 @@ pub fn evaluate_repl(
                 }
 
                 if shell_integration {
-                    // FIXME: use variant with exit code, if apropriate
-                    run_ansi_sequence(CMD_FINISHED_MARKER)?;
+                    run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
+                    if let Some(cwd) = stack.get_env_var(engine_state, "PWD") {
+                        let path = cwd.as_string()?;
+                        // Try to abbreviate string for windows title
+                        let maybe_abbrev_path = if let Some(p) = nu_path::home_dir() {
+                            path.replace(&p.as_path().display().to_string(), "~")
+                        } else {
+                            path
+                        };
+
+                        // Set window title too
+                        // https://tldp.org/HOWTO/Xterm-Title-3.html
+                        // ESC]0;stringBEL -- Set icon name and window title to string
+                        // ESC]1;stringBEL -- Set icon name to string
+                        // ESC]2;stringBEL -- Set window title to string
+                        run_ansi_sequence(&format!("\x1b]2;{}\x07", maybe_abbrev_path))?;
+                    }
                 }
             }
             Ok(Signal::CtrlC) => {
                 // `Reedline` clears the line content. New prompt is shown
                 if shell_integration {
-                    run_ansi_sequence(CMD_FINISHED_MARKER)?;
+                    run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
                 }
             }
             Ok(Signal::CtrlD) => {
                 // When exiting clear to a new line
                 if shell_integration {
-                    run_ansi_sequence(CMD_FINISHED_MARKER)?;
+                    run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
                 }
                 println!();
                 break;
@@ -482,7 +467,7 @@ pub fn evaluate_repl(
                     println!("Error: {:?}", err);
                 }
                 if shell_integration {
-                    run_ansi_sequence(CMD_FINISHED_MARKER)?;
+                    run_ansi_sequence(&get_command_finished_marker(stack, engine_state))?;
                 }
             }
         }
@@ -491,6 +476,285 @@ pub fn evaluate_repl(
     Ok(())
 }
 
+pub fn get_command_finished_marker(stack: &Stack, engine_state: &EngineState) -> String {
+    let exit_code = stack
+        .get_env_var(engine_state, "LAST_EXIT_CODE")
+        .and_then(|e| e.as_i64().ok());
+
+    format!("\x1b]133;D;{}\x1b\\", exit_code.unwrap_or(0))
+}
+
+pub fn eval_env_change_hook(
+    env_change_hook: Option<Value>,
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+) -> Result<(), ShellError> {
+    if let Some(hook) = env_change_hook {
+        match hook {
+            Value::Record {
+                cols: env_names,
+                vals: hook_values,
+                ..
+            } => {
+                for (env_name, hook_value) in env_names.iter().zip(hook_values.iter()) {
+                    let before = engine_state
+                        .previous_env_vars
+                        .get(env_name)
+                        .cloned()
+                        .unwrap_or_default();
+
+                    let after = stack
+                        .get_env_var(engine_state, env_name)
+                        .unwrap_or_default();
+
+                    if before != after {
+                        eval_hook(
+                            engine_state,
+                            stack,
+                            vec![("$before".into(), before), ("$after".into(), after.clone())],
+                            hook_value,
+                        )?;
+
+                        engine_state
+                            .previous_env_vars
+                            .insert(env_name.to_string(), after);
+                    }
+                }
+            }
+            x => {
+                return Err(ShellError::TypeMismatch(
+                    "record for the 'env_change' hook".to_string(),
+                    x.span()?,
+                ));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub fn eval_hook(
+    engine_state: &mut EngineState,
+    stack: &mut Stack,
+    arguments: Vec<(String, Value)>,
+    value: &Value,
+) -> Result<(), ShellError> {
+    let value_span = value.span()?;
+
+    let condition_path = PathMember::String {
+        val: "condition".to_string(),
+        span: value_span,
+    };
+
+    let code_path = PathMember::String {
+        val: "code".to_string(),
+        span: value_span,
+    };
+
+    match value {
+        Value::List { vals, .. } => {
+            for val in vals {
+                eval_hook(engine_state, stack, arguments.clone(), val)?
+            }
+        }
+        Value::Record { .. } => {
+            let do_run_hook =
+                if let Ok(condition) = value.clone().follow_cell_path(&[condition_path], false) {
+                    match condition {
+                        Value::Block {
+                            val: block_id,
+                            span: block_span,
+                            ..
+                        } => {
+                            match run_hook_block(
+                                engine_state,
+                                stack,
+                                block_id,
+                                arguments.clone(),
+                                block_span,
+                            ) {
+                                Ok(value) => match value {
+                                    Value::Bool { val, .. } => val,
+                                    other => {
+                                        return Err(ShellError::UnsupportedConfigValue(
+                                            "boolean output".to_string(),
+                                            format!("{}", other.get_type()),
+                                            other.span()?,
+                                        ));
+                                    }
+                                },
+                                Err(err) => {
+                                    return Err(err);
+                                }
+                            }
+                        }
+                        other => {
+                            return Err(ShellError::UnsupportedConfigValue(
+                                "block".to_string(),
+                                format!("{}", other.get_type()),
+                                other.span()?,
+                            ));
+                        }
+                    }
+                } else {
+                    // always run the hook
+                    true
+                };
+
+            if do_run_hook {
+                match value.clone().follow_cell_path(&[code_path], false)? {
+                    Value::String {
+                        val,
+                        span: source_span,
+                    } => {
+                        let (block, delta, vars) = {
+                            let mut working_set = StateWorkingSet::new(engine_state);
+
+                            let mut vars: Vec<(VarId, Value)> = vec![];
+
+                            for (name, val) in arguments {
+                                let var_id = working_set.add_variable(
+                                    name.as_bytes().to_vec(),
+                                    val.span()?,
+                                    Type::Any,
+                                );
+
+                                vars.push((var_id, val));
+                            }
+
+                            let (output, err) =
+                                parse(&mut working_set, Some("hook"), val.as_bytes(), false, &[]);
+                            if let Some(err) = err {
+                                report_error(&working_set, &err);
+
+                                return Err(ShellError::UnsupportedConfigValue(
+                                    "valid source code".into(),
+                                    "source code with syntax errors".into(),
+                                    source_span,
+                                ));
+                            }
+
+                            (output, working_set.render(), vars)
+                        };
+
+                        engine_state.merge_delta(delta)?;
+                        let input = PipelineData::new(value_span);
+
+                        let var_ids: Vec<VarId> = vars
+                            .into_iter()
+                            .map(|(var_id, val)| {
+                                stack.add_var(var_id, val);
+                                var_id
+                            })
+                            .collect();
+
+                        match eval_block(engine_state, stack, &block, input, false, false) {
+                            Ok(_) => {}
+                            Err(err) => {
+                                report_error_new(engine_state, &err);
+                            }
+                        }
+
+                        for var_id in var_ids.iter() {
+                            stack.vars.remove(var_id);
+                        }
+
+                        let cwd = get_guaranteed_cwd(engine_state, stack);
+                        engine_state.merge_env(stack, cwd)?;
+                    }
+                    Value::Block {
+                        val: block_id,
+                        span: block_span,
+                        ..
+                    } => {
+                        run_hook_block(engine_state, stack, block_id, arguments, block_span)?;
+                        let cwd = get_guaranteed_cwd(engine_state, stack);
+                        engine_state.merge_env(stack, cwd)?;
+                    }
+                    other => {
+                        return Err(ShellError::UnsupportedConfigValue(
+                            "block or string".to_string(),
+                            format!("{}", other.get_type()),
+                            other.span()?,
+                        ));
+                    }
+                }
+            }
+        }
+        Value::Block {
+            val: block_id,
+            span: block_span,
+            ..
+        } => {
+            run_hook_block(engine_state, stack, *block_id, arguments, *block_span)?;
+        }
+        other => {
+            return Err(ShellError::UnsupportedConfigValue(
+                "block, record, or list of records".into(),
+                format!("{}", other.get_type()),
+                other.span()?,
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+pub fn run_hook_block(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    block_id: BlockId,
+    arguments: Vec<(String, Value)>,
+    span: Span,
+) -> Result<Value, ShellError> {
+    let block = engine_state.get_block(block_id);
+
+    let input = PipelineData::new(span);
+
+    let mut callee_stack = stack.gather_captures(&block.captures);
+
+    for (idx, PositionalArg { var_id, .. }) in
+        block.signature.required_positional.iter().enumerate()
+    {
+        if let Some(var_id) = var_id {
+            if let Some(arg) = arguments.get(idx) {
+                callee_stack.add_var(*var_id, arg.1.clone())
+            } else {
+                return Err(ShellError::IncompatibleParametersSingle(
+                    "This hook block has too many parameters".into(),
+                    span,
+                ));
+            }
+        }
+    }
+
+    match eval_block(engine_state, &mut callee_stack, block, input, false, false) {
+        Ok(pipeline_data) => match pipeline_data.into_value(span) {
+            Value::Error { error } => Err(error),
+            val => {
+                // If all went fine, preserve the environment of the called block
+                let caller_env_vars = stack.get_env_var_names(engine_state);
+
+                // remove env vars that are present in the caller but not in the callee
+                // (the callee hid them)
+                for var in caller_env_vars.iter() {
+                    if !callee_stack.has_env_var(engine_state, var) {
+                        stack.remove_env_var(engine_state, var);
+                    }
+                }
+
+                // add new env vars from callee to caller
+                for (var, value) in callee_stack.get_stack_env_vars() {
+                    stack.add_env_var(var, value);
+                }
+
+                Ok(val)
+            }
+        },
+        Err(err) => Err(err),
+    }
+}
+
 fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
     match io::stdout().write_all(seq.as_bytes()) {
         Ok(it) => it,
@@ -515,62 +779,33 @@ fn run_ansi_sequence(seq: &str) -> Result<(), ShellError> {
     })
 }
 
-pub fn run_hook(
-    engine_state: &EngineState,
-    stack: &mut Stack,
-    arguments: Vec<Value>,
-    value: &Value,
-) -> Result<(), ShellError> {
-    match value {
-        Value::List { vals, .. } => {
-            for val in vals {
-                run_hook(engine_state, stack, arguments.clone(), val)?
-            }
-            Ok(())
-        }
-        Value::Block {
-            val: block_id,
-            span,
-            ..
-        } => run_hook_block(engine_state, stack, *block_id, arguments, *span),
-        x => match x.span() {
-            Ok(span) => Err(ShellError::MissingConfigValue(
-                "block for hook in config".into(),
-                span,
-            )),
-            _ => Err(ShellError::MissingConfigValue(
-                "block for hook in config".into(),
-                Span { start: 0, end: 0 },
-            )),
-        },
-    }
+lazy_static! {
+    // Absolute paths with a drive letter, like 'C:', 'D:\', 'E:\foo'
+    static ref DRIVE_PATH_REGEX: Regex =
+        Regex::new(r"^[a-zA-Z]:[/\\]?").expect("Internal error: regex creation");
 }
 
-pub fn run_hook_block(
-    engine_state: &EngineState,
-    stack: &mut Stack,
-    block_id: BlockId,
-    arguments: Vec<Value>,
-    span: Span,
-) -> Result<(), ShellError> {
-    let block = engine_state.get_block(block_id);
-    let input = PipelineData::new(span);
-
-    let mut callee_stack = stack.gather_captures(&block.captures);
-
-    for (idx, PositionalArg { var_id, .. }) in
-        block.signature.required_positional.iter().enumerate()
+// A best-effort "does this string look kinda like a path?" function to determine whether to auto-cd
+fn looks_like_path(orig: &str) -> bool {
+    #[cfg(windows)]
     {
-        if let Some(var_id) = var_id {
-            callee_stack.add_var(*var_id, arguments[idx].clone())
+        if DRIVE_PATH_REGEX.is_match(orig) {
+            return true;
         }
     }
 
-    match eval_block(engine_state, &mut callee_stack, block, input, false, false) {
-        Ok(pipeline_data) => match pipeline_data.into_value(span) {
-            Value::Error { error } => Err(error),
-            _ => Ok(()),
-        },
-        Err(err) => Err(err),
-    }
+    orig.starts_with('.')
+        || orig.starts_with('~')
+        || orig.starts_with('/')
+        || orig.starts_with('\\')
+}
+
+#[test]
+fn looks_like_path_windows_drive_path_works() {
+    let on_windows = cfg!(windows);
+    assert_eq!(looks_like_path("C:"), on_windows);
+    assert_eq!(looks_like_path("D:\\"), on_windows);
+    assert_eq!(looks_like_path("E:/"), on_windows);
+    assert_eq!(looks_like_path("F:\\some_dir"), on_windows);
+    assert_eq!(looks_like_path("G:/some_dir"), on_windows);
 }

crates/nu-cli/src/util.rs

@@ -224,16 +224,11 @@ pub fn eval_source(
         (output, working_set.render())
     };
 
-    let cwd = match nu_engine::env::current_dir(engine_state, stack) {
-        Ok(p) => p,
-        Err(e) => {
-            let working_set = StateWorkingSet::new(engine_state);
-            report_error(&working_set, &e);
-            get_init_cwd()
-        }
-    };
-
-    let _ = engine_state.merge_delta(delta, Some(stack), &cwd);
+    if let Err(err) = engine_state.merge_delta(delta) {
+        set_last_exit_code(stack, 1);
+        report_error_new(engine_state, &err);
+        return false;
+    }
 
     match eval_block(engine_state, stack, &block, input, false, false) {
         Ok(mut pipeline_data) => {
@@ -297,6 +292,15 @@ pub fn report_error(
     }
 }
 
+pub fn report_error_new(
+    engine_state: &EngineState,
+    error: &(dyn miette::Diagnostic + Send + Sync + 'static),
+) {
+    let working_set = StateWorkingSet::new(engine_state);
+
+    report_error(&working_set, error);
+}
+
 pub fn get_init_cwd() -> PathBuf {
     match std::env::current_dir() {
         Ok(cwd) => cwd,
@@ -310,6 +314,17 @@ pub fn get_init_cwd() -> PathBuf {
     }
 }
 
+pub fn get_guaranteed_cwd(engine_state: &EngineState, stack: &Stack) -> PathBuf {
+    match nu_engine::env::current_dir(engine_state, stack) {
+        Ok(p) => p,
+        Err(e) => {
+            let working_set = StateWorkingSet::new(engine_state);
+            report_error(&working_set, &e);
+            get_init_cwd()
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

crates/nu-cli/tests/custom_completions.rs

@@ -2,10 +2,24 @@ pub mod support;
 
 use nu_cli::NuCompleter;
 use reedline::Completer;
+use rstest::{fixture, rstest};
 use support::{match_suggestions, new_engine};
 
-#[test]
-fn variables_completions() {
+#[fixture]
+fn completer() -> NuCompleter {
+    // Create a new engine
+    let (dir, _, mut engine, mut stack) = new_engine();
+
+    // Add record value as example
+    let record = "def tst [--mod -s] {}";
+    assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
+
+    // Instantiate a new completer
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
+
+#[fixture]
+fn completer_strings() -> NuCompleter {
     // Create a new engine
     let (dir, _, mut engine, mut stack) = new_engine();
 
@@ -15,15 +29,41 @@ fn variables_completions() {
     assert!(support::merge_input(record.as_bytes(), &mut engine, &mut stack, dir).is_ok());
 
     // Instantiate a new completer
-    let mut completer = NuCompleter::new(std::sync::Arc::new(engine), stack);
+    NuCompleter::new(std::sync::Arc::new(engine), stack)
+}
 
-    // Test completions for $nu
-    let suggestions = completer.complete("my-command ", 11);
-
-    assert_eq!(3, suggestions.len());
-
-    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
-
-    // Match results
+#[rstest]
+fn variables_completions_double_dash_argument(mut completer: NuCompleter) {
+    let suggestions = completer.complete("tst --", 6);
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into()];
+    // dbg!(&expected, &suggestions);
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_completions_single_dash_argument(mut completer: NuCompleter) {
+    let suggestions = completer.complete("tst -", 5);
+    let expected: Vec<String> = vec!["--help".into(), "--mod".into(), "-h".into(), "-s".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_completions_command(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command ", 9);
+    let expected: Vec<String> = vec!["my-command".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_completions_subcommands(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command ", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
+    match_suggestions(expected, suggestions);
+}
+
+#[rstest]
+fn variables_completions_subcommands_2(mut completer_strings: NuCompleter) {
+    let suggestions = completer_strings.complete("my-command ", 11);
+    let expected: Vec<String> = vec!["cat".into(), "dog".into(), "eel".into()];
     match_suggestions(expected, suggestions);
 }

crates/nu-cli/tests/file_completions.rs

@@ -30,8 +30,8 @@ fn file_completions() {
     // Match the results
     match_suggestions(expected_paths, suggestions);
 
-    // Test completions for the completions/another folder
-    let target_dir = format!("cd {}", folder(dir.join("another")));
+    // Test completions for a file
+    let target_dir = format!("cp {}", folder(dir.join("another")));
     let suggestions = completer.complete(&target_dir, target_dir.len());
 
     // Create the expected values

crates/nu-cli/tests/flag_completions.rs

@@ -14,15 +14,17 @@ fn flag_completions() {
     // Test completions for the 'ls' flags
     let suggestions = completer.complete("ls -", 4);
 
-    assert_eq!(12, suggestions.len());
+    assert_eq!(14, suggestions.len());
 
     let expected: Vec<String> = vec![
         "--all".into(),
+        "--directory".into(),
         "--du".into(),
         "--full-paths".into(),
         "--help".into(),
         "--long".into(),
         "--short-names".into(),
+        "-D".into(),
         "-a".into(),
         "-d".into(),
         "-f".into(),

crates/nu-cli/tests/support/completions_helpers.rs

@@ -4,7 +4,7 @@ use nu_command::create_default_context;
 use nu_engine::eval_block;
 use nu_parser::parse;
 use nu_protocol::{
-    engine::{EngineState, Stack, StateDelta, StateWorkingSet},
+    engine::{EngineState, Stack, StateWorkingSet},
     PipelineData, ShellError, Span, Value,
 };
 use nu_test_support::fs;
@@ -23,14 +23,11 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
     dir_str.push(SEP);
 
     // Create a new engine with default context
-    let mut engine_state = create_default_context(&dir);
+    let mut engine_state = create_default_context();
 
     // New stack
     let mut stack = Stack::new();
 
-    // New delta state
-    let delta = StateDelta::new(&engine_state);
-
     // Add pwd as env var
     stack.add_env_var(
         "PWD".to_string(),
@@ -53,8 +50,8 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
         },
     );
 
-    // Merge delta
-    let merge_result = engine_state.merge_delta(delta, Some(&mut stack), &dir);
+    // Merge environment into the permanent state
+    let merge_result = engine_state.merge_env(&mut stack, &dir);
     assert!(merge_result.is_ok());
 
     (dir, dir_str, engine_state, stack)
@@ -62,6 +59,15 @@ pub fn new_engine() -> (PathBuf, String, EngineState, Stack) {
 
 // match a list of suggestions with the expected values
 pub fn match_suggestions(expected: Vec<String>, suggestions: Vec<Suggestion>) {
+    let expected_len = expected.len();
+    let suggestions_len = suggestions.len();
+    if expected_len != suggestions_len {
+        panic!(
+            "\nexpected {expected_len} suggestions but got {suggestions_len}: \n\
+            Suggestions: {suggestions:#?} \n\
+            Expected: {expected:#?}\n"
+        )
+    }
     expected.iter().zip(suggestions).for_each(|it| {
         assert_eq!(it.0, &it.1.value);
     });
@@ -97,6 +103,11 @@ pub fn merge_input(
 
         (block, working_set.render())
     };
+
+    if let Err(err) = engine_state.merge_delta(delta) {
+        return Err(err);
+    }
+
     assert!(eval_block(
         engine_state,
         stack,
@@ -112,6 +123,6 @@ pub fn merge_input(
     )
     .is_ok());
 
-    // Merge delta
-    engine_state.merge_delta(delta, Some(stack), &dir)
+    // Merge environment into the permanent state
+    engine_state.merge_env(stack, &dir)
 }

crates/nu-color-config/Cargo.toml

@@ -4,11 +4,11 @@ description = "Color configuration code used by Nushell"
 edition = "2021"
 license = "MIT"
 name = "nu-color-config"
-version = "0.65.0"
+version = "0.66.0"
 
 [dependencies]
-nu-protocol = { path = "../nu-protocol", version = "0.65.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.0"  }
 nu-ansi-term = "0.46.0"
-nu-json = { path = "../nu-json", version = "0.65.0"  }
-nu-table = { path = "../nu-table", version = "0.65.0"  }
+nu-json = { path = "../nu-json", version = "0.66.0"  }
+nu-table = { path = "../nu-table", version = "0.66.0"  }
 serde = { version="1.0.123", features=["derive"] }

crates/nu-command/Cargo.toml

@@ -4,25 +4,25 @@ description = "Nushell's built-in commands"
 edition = "2021"
 license = "MIT"
 name = "nu-command"
-version = "0.65.0"
+version = "0.66.0"
 build = "build.rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nu-color-config = { path = "../nu-color-config", version = "0.65.0"  }
-nu-engine = { path = "../nu-engine", version = "0.65.0"  }
-nu-glob = { path = "../nu-glob", version = "0.65.0" }
-nu-json = { path = "../nu-json", version = "0.65.0"  }
-nu-parser = { path = "../nu-parser", version = "0.65.0"  }
-nu-path = { path = "../nu-path", version = "0.65.0"  }
-nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.65.0"  }
-nu-protocol = { path = "../nu-protocol", version = "0.65.0"  }
-nu-system = { path = "../nu-system", version = "0.65.0"  }
-nu-table = { path = "../nu-table", version = "0.65.0"  }
-nu-term-grid = { path = "../nu-term-grid", version = "0.65.0"  }
-nu-test-support = { path = "../nu-test-support", version = "0.65.0"  }
-nu-utils = { path = "../nu-utils", version = "0.65.0" }
+nu-color-config = { path = "../nu-color-config", version = "0.66.0"  }
+nu-engine = { path = "../nu-engine", version = "0.66.0"  }
+nu-glob = { path = "../nu-glob", version = "0.66.0" }
+nu-json = { path = "../nu-json", version = "0.66.0"  }
+nu-parser = { path = "../nu-parser", version = "0.66.0"  }
+nu-path = { path = "../nu-path", version = "0.66.0"  }
+nu-pretty-hex = { path = "../nu-pretty-hex", version = "0.66.0"  }
+nu-protocol = { path = "../nu-protocol", version = "0.66.0"  }
+nu-system = { path = "../nu-system", version = "0.66.0"  }
+nu-table = { path = "../nu-table", version = "0.66.0"  }
+nu-term-grid = { path = "../nu-term-grid", version = "0.66.0"  }
+nu-test-support = { path = "../nu-test-support", version = "0.66.0"  }
+nu-utils = { path = "../nu-utils", version = "0.66.0" }
 nu-ansi-term = "0.46.0"
 
 # Potential dependencies for extras
@@ -52,15 +52,15 @@ is-root = "0.1.2"
 itertools = "0.10.0"
 lazy_static = "1.4.0"
 log = "0.4.14"
-lscolors = { version = "0.9.0", features = ["crossterm"]}
+lscolors = { version = "0.10.0", features = ["crossterm"]}
 md5 = { package = "md-5", version = "0.10.0" }
 meval = "0.2.0"
 mime = "0.3.16"
 notify = "4.0.17"
 num = { version = "0.4.0", optional = true }
 pathdiff = "0.2.1"
-powierza-coefficient = "1.0"
-quick-xml = "0.22"
+powierza-coefficient = "1.0.1"
+quick-xml = "0.23.0"
 rand = "0.8"
 rayon = "1.5.1"
 regex = "1.5.4"
@@ -73,26 +73,25 @@ serde_urlencoded = "0.7.0"
 serde_yaml = "0.8.16"
 sha2 = "0.10.0"
 # Disable default features b/c the default features build Git (very slow to compile)
-shadow-rs = { version = "0.11.0", default-features = false }
+shadow-rs = { version = "0.16.1", default-features = false }
 strip-ansi-escapes = "0.1.1"
-sysinfo = "0.23.5"
-terminal_size = "0.1.17"
+sysinfo = "0.24.6"
+terminal_size = "0.2.1"
 thiserror = "1.0.31"
-titlecase = "1.1.0"
+titlecase = "2.0.0"
 toml = "0.5.8"
 unicode-segmentation = "1.8.0"
 url = "2.2.1"
-uuid = { version = "0.8.2", features = ["v4"] }
+uuid = { version = "1.1.2", features = ["v4"] }
 which = { version = "4.2.2", optional = true }
-reedline = { version = "0.8.0", features = ["bashisms", "sqlite"]}
-wax = { version =  "0.4.0", features = ["diagnostics"] }
-rusqlite = { version = "0.27.0", features = ["bundled"], optional = true }
+reedline = { version = "0.9.0", features = ["bashisms", "sqlite"]}
+wax = { version =  "0.5.0", features = ["diagnostics"] }
+rusqlite = { version = "0.28.0", features = ["bundled"], optional = true }
 sqlparser = { version = "0.16.0", features = ["serde"], optional = true }
 
 [target.'cfg(unix)'.dependencies]
 umask = "2.0.0"
 users = "0.11.0"
-signal-hook = { version = "0.3.14", default-features = false }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies.trash]
 version = "2.1.3"
@@ -106,8 +105,8 @@ features = [
 	"default", "to_dummies", "parquet", "json", "serde", "serde-lazy",
 	"object", "checked_arithmetic", "strings", "cum_agg", "is_in",
 	"rolling_window", "strings", "rows", "random",
-  "dtype-datetime", "dtype-struct", "lazy", "cross_join",
-	"dynamic_groupby", "dtype-categorical"
+    "dtype-datetime", "dtype-struct", "lazy", "cross_join",
+	"dynamic_groupby", "dtype-categorical", "concat_str"
 ]
 
 [target.'cfg(windows)'.dependencies.windows]
@@ -127,11 +126,11 @@ dataframe = ["polars", "num"]
 database = ["sqlparser", "rusqlite"]
 
 [build-dependencies]
-shadow-rs = { version = "0.11.0", default-features = false }
+shadow-rs = { version = "0.16.1", default-features = false }
 
 [dev-dependencies]
 hamcrest2 = "0.3.0"
 dirs-next = "2.0.0"
 quickcheck = "1.0.3"
 quickcheck_macros = "1.0.0"
-rstest = "0.12.0"
+rstest = "0.15.0"

crates/nu-command/src/bytes/add.rs

@@ -0,0 +1,167 @@
+use super::{operate, BytesArgument};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::ast::CellPath;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::Category;
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
+
+struct Arguments {
+    added_data: Vec<u8>,
+    index: Option<usize>,
+    end: bool,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesAdd;
+
+impl Command for BytesAdd {
+    fn name(&self) -> &str {
+        "bytes add"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes add")
+            .required("data", SyntaxShape::Binary, "the binary to add")
+            .named(
+                "index",
+                SyntaxShape::Int,
+                "index to insert binary data",
+                Some('i'),
+            )
+            .switch("end", "add to the end of binary", Some('e'))
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally matches prefix of text by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "add specified bytes to the input"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["append", "truncate", "padding"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let added_data: Vec<u8> = call.req(engine_state, stack, 0)?;
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let index: Option<usize> = call.get_flag(engine_state, stack, "index")?;
+        let end = call.has_flag("end");
+
+        let arg = Arguments {
+            added_data,
+            index,
+            end,
+            column_paths,
+        };
+        operate(add, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Add bytes `0x[AA]` to `0x[1F FF AA AA]`",
+                example: "0x[1F FF AA AA] | bytes add 0x[AA]",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0x1F, 0xFF, 0xAA, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[AA BB]` to `0x[1F FF AA AA]` at index 1",
+                example: "0x[1F FF AA AA] | bytes add 0x[AA BB] -i 1",
+                result: Some(Value::Binary {
+                    val: vec![0x1F, 0xAA, 0xBB, 0xFF, 0xAA, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[11]` to `0x[FF AA AA]` at the end",
+                example: "0x[FF AA AA] | bytes add 0x[11] -e",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0xAA, 0x11],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Add bytes `0x[11 22 33]` to `0x[FF AA AA]` at the end, at index 1(the index is start from end)",
+                example: "0x[FF AA BB] | bytes add 0x[11 22 33] -e -i 1",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0x11, 0x22, 0x33, 0xBB],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn add(input: &[u8], args: &Arguments, span: Span) -> Value {
+    match args.index {
+        None => {
+            if args.end {
+                let mut added_data = args.added_data.clone();
+                let mut result = input.to_vec();
+                result.append(&mut added_data);
+                Value::Binary { val: result, span }
+            } else {
+                let mut result = args.added_data.clone();
+                let mut input = input.to_vec();
+                result.append(&mut input);
+                Value::Binary { val: result, span }
+            }
+        }
+        Some(mut indx) => {
+            let inserted_index = if args.end {
+                input.len().saturating_sub(indx)
+            } else {
+                if indx > input.len() {
+                    indx = input.len()
+                }
+                indx
+            };
+            let mut result = vec![];
+            let mut prev_data = input[..inserted_index].to_vec();
+            result.append(&mut prev_data);
+            let mut added_data = args.added_data.clone();
+            result.append(&mut added_data);
+            let mut after_data = input[inserted_index..].to_vec();
+            result.append(&mut after_data);
+            Value::Binary { val: result, span }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesAdd {})
+    }
+}

crates/nu-command/src/bytes/at.rs

@@ -0,0 +1,281 @@
+use super::{operate, BytesArgument};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::ast::CellPath;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+};
+use std::cmp::Ordering;
+
+#[derive(Clone)]
+pub struct BytesAt;
+
+struct Arguments {
+    start: isize,
+    end: isize,
+    arg_span: Span,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+/// ensure given `range` is valid, and returns [start, end, val_span] pair.
+fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellError> {
+    let (start, end, span) = match range {
+        Value::List { mut vals, span } => {
+            if vals.len() != 2 {
+                return Err(ShellError::UnsupportedInput(
+                    "More than two indices given".to_string(),
+                    span,
+                ));
+            } else {
+                let end = vals.pop().expect("Already check has size 2");
+                let end = match end {
+                    Value::Int { val, .. } => val.to_string(),
+                    Value::String { val, .. } => val,
+                    other => {
+                        return Err(ShellError::UnsupportedInput(
+                            "could not perform subbytes. Expecting a string or int".to_string(),
+                            other.span().unwrap_or(head),
+                        ))
+                    }
+                };
+                let start = vals.pop().expect("Already check has size 1");
+                let start = match start {
+                    Value::Int { val, .. } => val.to_string(),
+                    Value::String { val, .. } => val,
+                    other => {
+                        return Err(ShellError::UnsupportedInput(
+                            "could not perform subbytes. Expecting a string or int".to_string(),
+                            other.span().unwrap_or(head),
+                        ))
+                    }
+                };
+                (start, end, span)
+            }
+        }
+        Value::String { val, span } => {
+            let splitted_result = val.split_once(',');
+            match splitted_result {
+                Some((start, end)) => (start.to_string(), end.to_string(), span),
+                None => {
+                    return Err(ShellError::UnsupportedInput(
+                        "could not perform subbytes".to_string(),
+                        span,
+                    ))
+                }
+            }
+        }
+        other => {
+            return Err(ShellError::UnsupportedInput(
+                "could not perform subbytes".to_string(),
+                other.span().unwrap_or(head),
+            ))
+        }
+    };
+
+    let start: isize = if start.is_empty() || start == "_" {
+        0
+    } else {
+        match start.trim().parse() {
+            Ok(s) => s,
+            Err(_) => {
+                return Err(ShellError::UnsupportedInput(
+                    "could not perform subbytes".to_string(),
+                    span,
+                ))
+            }
+        }
+    };
+    let end: isize = if end.is_empty() || end == "_" {
+        isize::max_value()
+    } else {
+        match end.trim().parse() {
+            Ok(s) => s,
+            Err(_) => {
+                return Err(ShellError::UnsupportedInput(
+                    "could not perform subbytes".to_string(),
+                    span,
+                ))
+            }
+        }
+    };
+    Ok((start, end, span))
+}
+
+impl Command for BytesAt {
+    fn name(&self) -> &str {
+        "bytes at"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes at")
+            .required("range", SyntaxShape::Any, "the indexes to get bytes")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally get bytes by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Get bytes defined by a range. Note that the start is included but the end is excluded, and that the first byte is index 0."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["slice"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let range: Value = call.req(engine_state, stack, 0)?;
+        let (start, end, arg_span) = parse_range(range, call.head)?;
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let arg = Arguments {
+            start,
+            end,
+            arg_span,
+            column_paths,
+        };
+        operate(at, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Get a subbytes `0x[10 01]` from the bytes `0x[33 44 55 10 01 13]`",
+                example: " 0x[33 44 55 10 01 13] | bytes at [3 4]",
+                result: Some(Value::Binary {
+                    val: vec![0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Alternatively, you can use the form",
+                example: " 0x[33 44 55 10 01 13] | bytes at '3,4'",
+                result: Some(Value::Binary {
+                    val: vec![0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Drop the last `n` characters from the string",
+                example: " 0x[33 44 55 10 01 13] | bytes at ',-3'",
+                result: Some(Value::Binary {
+                    val: vec![0x33, 0x44, 0x55],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Get the remaining characters from a starting index",
+                example: " 0x[33 44 55 10 01 13] | bytes at '3,'",
+                result: Some(Value::Binary {
+                    val: vec![0x10, 0x01, 0x13],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Get the characters from the beginning until ending index",
+                example: " 0x[33 44 55 10 01 13] | bytes at ',4'",
+                result: Some(Value::Binary {
+                    val: vec![0x33, 0x44, 0x55, 0x10],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description:
+                    "Or the characters from the beginning until ending index inside a table",
+                example: r#" [[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes at "1," ColB ColC"#,
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x11, 0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn at(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let len: isize = input.len() as isize;
+
+    let start: isize = if arg.start < 0 {
+        arg.start + len
+    } else {
+        arg.start
+    };
+    let end: isize = if arg.end < 0 {
+        std::cmp::max(len + arg.end, 0)
+    } else {
+        arg.end
+    };
+
+    if start < len && end >= 0 {
+        match start.cmp(&end) {
+            Ordering::Equal => Value::Binary { val: vec![], span },
+            Ordering::Greater => Value::Error {
+                error: ShellError::UnsupportedInput(
+                    "End must be greater than or equal to Start".to_string(),
+                    arg.arg_span,
+                ),
+            },
+            Ordering::Less => Value::Binary {
+                val: {
+                    let input_iter = input.iter().copied().skip(start as usize);
+                    if end == isize::max_value() {
+                        input_iter.collect()
+                    } else {
+                        input_iter.take((end - start) as usize).collect()
+                    }
+                },
+                span,
+            },
+        }
+    } else {
+        Value::Binary { val: vec![], span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesAt {})
+    }
+}

crates/nu-command/src/bytes/build_.rs

@@ -0,0 +1,81 @@
+use nu_engine::eval_expression;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Value,
+};
+
+#[derive(Clone)]
+pub struct BytesBuild;
+
+impl Command for BytesBuild {
+    fn name(&self) -> &str {
+        "bytes build"
+    }
+
+    fn usage(&self) -> &str {
+        "Create bytes from the arguments."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["concatenate", "join"]
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("bytes build")
+            .rest("rest", SyntaxShape::Any, "list of bytes")
+            .category(Category::Bytes)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            example: "bytes build 0x[01 02] 0x[03] 0x[04]",
+            description: "Builds binary data from 0x[01 02], 0x[03], 0x[04]",
+            result: Some(Value::Binary {
+                val: vec![0x01, 0x02, 0x03, 0x04],
+                span: Span::test_data(),
+            }),
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let mut output = vec![];
+        for expr in call.positional_iter() {
+            let val = eval_expression(engine_state, stack, expr)?;
+            match val {
+                Value::Binary { mut val, .. } => output.append(&mut val),
+                other => {
+                    return Err(ShellError::UnsupportedInput(
+                        "only support expression which yields to binary data".to_string(),
+                        other.span().unwrap_or(call.head),
+                    ))
+                }
+            }
+        }
+
+        Ok(Value::Binary {
+            val: output,
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesBuild {})
+    }
+}

crates/nu-command/src/bytes/bytes_.rs

@@ -0,0 +1,49 @@
+use nu_engine::get_full_help;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, IntoPipelineData, PipelineData, Signature, Value,
+};
+
+#[derive(Clone)]
+pub struct Bytes;
+
+impl Command for Bytes {
+    fn name(&self) -> &str {
+        "bytes"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes").category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Various commands for working with byte data"
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        Ok(Value::String {
+            val: get_full_help(&Bytes.signature(), &Bytes.examples(), engine_state, stack),
+            span: call.head,
+        }
+        .into_pipeline_data())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::Bytes;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Bytes {})
+    }
+}

crates/nu-command/src/bytes/collect.rs

@@ -0,0 +1,127 @@
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, SyntaxShape,
+    Value,
+};
+
+#[derive(Clone, Copy)]
+pub struct BytesCollect;
+
+impl Command for BytesCollect {
+    fn name(&self) -> &str {
+        "bytes collect"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes collect")
+            .optional(
+                "separator",
+                SyntaxShape::Binary,
+                "optional separator to use when creating binary",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Concatenate multiple binary into a single binary, with an optional separator between each"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["join", "concatenate"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let separator: Option<Vec<u8>> = call.opt(engine_state, stack, 0)?;
+        // input should be a list of binary data.
+        let mut output_binary = vec![];
+        for value in input {
+            match value {
+                Value::Binary { mut val, .. } => {
+                    output_binary.append(&mut val);
+                    // manually concat
+                    // TODO: make use of std::slice::Join when it's available in stable.
+                    if let Some(sep) = &separator {
+                        let mut work_sep = sep.clone();
+                        output_binary.append(&mut work_sep)
+                    }
+                }
+                other => {
+                    return Err(ShellError::UnsupportedInput(
+                        format!(
+                            "The element type is {}, this command only works with bytes.",
+                            other.get_type()
+                        ),
+                        other.span().unwrap_or(call.head),
+                    ))
+                }
+            }
+        }
+
+        match separator {
+            None => Ok(Value::Binary {
+                val: output_binary,
+                span: call.head,
+            }
+            .into_pipeline_data()),
+            Some(sep) => {
+                if output_binary.is_empty() {
+                    Ok(Value::Binary {
+                        val: output_binary,
+                        span: call.head,
+                    }
+                    .into_pipeline_data())
+                } else {
+                    // have push one extra separator in previous step, pop them out.
+                    for _ in sep {
+                        let _ = output_binary.pop();
+                    }
+                    Ok(Value::Binary {
+                        val: output_binary,
+                        span: call.head,
+                    }
+                    .into_pipeline_data())
+                }
+            }
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Create a byte array from input",
+                example: "[0x[11] 0x[13 15]] | bytes collect",
+                result: Some(Value::Binary {
+                    val: vec![0x11, 0x13, 0x15],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Create a byte array from input with a separator",
+                example: "[0x[11] 0x[33] 0x[44]] | bytes collect 0x[01]",
+                result: Some(Value::Binary {
+                    val: vec![0x11, 0x01, 0x33, 0x01, 0x44],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesCollect {})
+    }
+}

crates/nu-command/src/bytes/ends_with.rs

@@ -0,0 +1,116 @@
+use super::{operate, BytesArgument};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::ast::CellPath;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::Category;
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesEndsWith;
+
+impl Command for BytesEndsWith {
+    fn name(&self) -> &str {
+        "bytes ends-with"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes ends-with")
+            .required("pattern", SyntaxShape::Binary, "the pattern to match")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally matches prefix of text by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Check if bytes ends with a pattern"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pattern", "match", "find", "search"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let arg = Arguments {
+            pattern,
+            column_paths,
+        };
+        operate(ends_with, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Checks if binary ends with `0x[AA]`",
+                example: "0x[1F FF AA AA] | bytes ends-with 0x[AA]",
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Checks if binary ends with `0x[FF AA AA]`",
+                example: "0x[1F FF AA AA] | bytes ends-with 0x[FF AA AA]",
+                result: Some(Value::Bool {
+                    val: true,
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Checks if binary ends with `0x[11]`",
+                example: "0x[1F FF AA AA] | bytes ends-with 0x[11]",
+                result: Some(Value::Bool {
+                    val: false,
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn ends_with(input: &[u8], Arguments { pattern, .. }: &Arguments, span: Span) -> Value {
+    Value::Bool {
+        val: input.ends_with(pattern),
+        span,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesEndsWith {})
+    }
+}

crates/nu-command/src/bytes/index_of.rs

@@ -0,0 +1,210 @@
+use super::{operate, BytesArgument};
+use nu_engine::CallExt;
+use nu_protocol::ast::{Call, CellPath};
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
+};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    end: bool,
+    all: bool,
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesIndexOf;
+
+impl Command for BytesIndexOf {
+    fn name(&self) -> &str {
+        "bytes index-of"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes index-of")
+            .required(
+                "pattern",
+                SyntaxShape::Binary,
+                "the pattern to find index of",
+            )
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally returns index of pattern in string by column paths",
+            )
+            .switch("all", "returns all matched index", Some('a'))
+            .switch("end", "search from the end of the binary", Some('e'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Returns start index of first occurrence of pattern in bytes, or -1 if no match"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pattern", "match", "find", "search", "index"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let pattern: Vec<u8> = call.req(engine_state, stack, 0)?;
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let arg = Arguments {
+            pattern,
+            end: call.has_flag("end"),
+            all: call.has_flag("all"),
+            column_paths,
+        };
+        operate(index_of, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Returns index of pattern in bytes",
+                example: " 0x[33 44 55 10 01 13 44 55] | bytes index-of 0x[44 55]",
+                result: Some(Value::test_int(1)),
+            },
+            Example {
+                description: "Returns index of pattern, search from end",
+                example: " 0x[33 44 55 10 01 13 44 55] | bytes index-of -e 0x[44 55]",
+                result: Some(Value::test_int(6)),
+            },
+            Example {
+                description: "Returns all matched index",
+                example: " 0x[33 44 55 10 01 33 44 33 44] | bytes index-of -a 0x[33 44]",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(0), Value::test_int(5), Value::test_int(7)],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Returns all matched index, searching from end",
+                example: " 0x[33 44 55 10 01 33 44 33 44] | bytes index-of -a -e 0x[33 44]",
+                result: Some(Value::List {
+                    vals: vec![Value::test_int(7), Value::test_int(5), Value::test_int(0)],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Returns index of pattern for specific column",
+                example: r#" [[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes index-of 0x[11] ColA ColC"#,
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::test_int(0),
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::test_int(-1),
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn index_of(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    if arg.all {
+        search_all_index(input, &arg.pattern, arg.end, span)
+    } else {
+        let mut iter = input.windows(arg.pattern.len());
+
+        if arg.end {
+            Value::Int {
+                val: iter
+                    .rev()
+                    .position(|sub_bytes| sub_bytes == arg.pattern)
+                    .map(|x| (input.len() - arg.pattern.len() - x) as i64)
+                    .unwrap_or(-1),
+                span,
+            }
+        } else {
+            Value::Int {
+                val: iter
+                    .position(|sub_bytes| sub_bytes == arg.pattern)
+                    .map(|x| x as i64)
+                    .unwrap_or(-1),
+                span,
+            }
+        }
+    }
+}
+
+fn search_all_index(input: &[u8], pattern: &[u8], from_end: bool, span: Span) -> Value {
+    let mut result = vec![];
+    if from_end {
+        let (mut left, mut right) = (
+            input.len() as isize - pattern.len() as isize,
+            input.len() as isize,
+        );
+        while left >= 0 {
+            if &input[left as usize..right as usize] == pattern {
+                result.push(Value::Int {
+                    val: left as i64,
+                    span,
+                });
+                left -= pattern.len() as isize;
+                right -= pattern.len() as isize;
+            } else {
+                left -= 1;
+                right -= 1;
+            }
+        }
+        Value::List { vals: result, span }
+    } else {
+        // doing find stuff.
+        let (mut left, mut right) = (0, pattern.len());
+        let input_len = input.len();
+        let pattern_len = pattern.len();
+        while right <= input_len {
+            if &input[left..right] == pattern {
+                result.push(Value::Int {
+                    val: left as i64,
+                    span,
+                });
+                left += pattern_len;
+                right += pattern_len;
+            } else {
+                left += 1;
+                right += 1;
+            }
+        }
+
+        Value::List { vals: result, span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesIndexOf {})
+    }
+}

crates/nu-command/src/bytes/mod.rs

@@ -1,11 +1,32 @@
+mod add;
+mod at;
+mod build_;
+mod bytes_;
+mod collect;
+mod ends_with;
+mod index_of;
 mod length;
+mod remove;
+mod replace;
+mod reverse;
 mod starts_with;
+
 use nu_protocol::ast::CellPath;
 use nu_protocol::{PipelineData, ShellError, Span, Value};
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 
+pub use add::BytesAdd;
+pub use at::BytesAt;
+pub use build_::BytesBuild;
+pub use bytes_::Bytes;
+pub use collect::BytesCollect;
+pub use ends_with::BytesEndsWith;
+pub use index_of::BytesIndexOf;
 pub use length::BytesLen;
+pub use remove::BytesRemove;
+pub use replace::BytesReplace;
+pub use reverse::BytesReverse;
 pub use starts_with::BytesStartsWith;
 
 trait BytesArgument {

crates/nu-command/src/bytes/remove.rs

@@ -0,0 +1,196 @@
+use super::{operate, BytesArgument};
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
+};
+
+struct Arguments {
+    pattern: Vec<u8>,
+    end: bool,
+    column_paths: Option<Vec<CellPath>>,
+    all: bool,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesRemove;
+
+impl Command for BytesRemove {
+    fn name(&self) -> &str {
+        "bytes remove"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes remove")
+            .required("pattern", SyntaxShape::Binary, "the pattern to find")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally remove bytes by column paths",
+            )
+            .switch("end", "remove from end of binary", Some('e'))
+            .switch("all", "remove occurrences of finding binary", Some('a'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "remove bytes"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["search", "shift", "switch"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 1)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let pattern_to_remove = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
+        if pattern_to_remove.item.is_empty() {
+            return Err(ShellError::UnsupportedInput(
+                "the pattern to remove cannot be empty".to_string(),
+                pattern_to_remove.span,
+            ));
+        }
+
+        let pattern_to_remove: Vec<u8> = pattern_to_remove.item;
+        let arg = Arguments {
+            pattern: pattern_to_remove,
+            end: call.has_flag("end"),
+            column_paths,
+            all: call.has_flag("all"),
+        };
+
+        operate(remove, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Remove contents",
+                example: "0x[10 AA FF AA FF] | bytes remove 0x[10 AA]",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove all occurrences of find binary",
+                example: "0x[10 AA 10 BB 10] | bytes remove -a 0x[10]",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xBB],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove occurrences of find binary from end",
+                example: "0x[10 AA 10 BB CC AA 10] | bytes remove -e 0x[10]",
+                result: Some(Value::Binary {
+                    val: vec![0x10, 0xAA, 0x10, 0xBB, 0xCC, 0xAA],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Remove all occurrences of find binary in table",
+                example: "[[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes remove 0x[11] ColA ColC",
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x17, 0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn remove(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let mut result = vec![];
+    let remove_all = arg.all;
+    let input_len = input.len();
+    let pattern_len = arg.pattern.len();
+
+    // Note:
+    // remove_all from start and end will generate the same result.
+    // so we'll put `remove_all` relative logic into else clouse.
+    if arg.end && !remove_all {
+        let (mut left, mut right) = (
+            input.len() as isize - arg.pattern.len() as isize,
+            input.len() as isize,
+        );
+        while left >= 0 && input[left as usize..right as usize] != arg.pattern {
+            result.push(input[right as usize - 1]);
+            left -= 1;
+            right -= 1;
+        }
+        // append the remaining thing to result, this can be happeneed when
+        // we have something to remove and remove_all is False.
+        let mut remain = input[..left as usize].iter().copied().rev().collect();
+        result.append(&mut remain);
+        result = result.into_iter().rev().collect();
+        Value::Binary { val: result, span }
+    } else {
+        let (mut left, mut right) = (0, arg.pattern.len());
+        while right <= input_len {
+            if input[left..right] == arg.pattern {
+                left += pattern_len;
+                right += pattern_len;
+                if !remove_all {
+                    break;
+                }
+            } else {
+                result.push(input[left]);
+                left += 1;
+                right += 1;
+            }
+        }
+        // append the remaing thing to result, this can happened when
+        // we have something to remove and remove_all is False.
+        let mut remain = input[left..].to_vec();
+        result.append(&mut remain);
+        Value::Binary { val: result, span }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesRemove {})
+    }
+}

crates/nu-command/src/bytes/replace.rs

@@ -0,0 +1,171 @@
+use super::{operate, BytesArgument};
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::{Call, CellPath},
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
+};
+
+struct Arguments {
+    find: Vec<u8>,
+    replace: Vec<u8>,
+    column_paths: Option<Vec<CellPath>>,
+    all: bool,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+pub struct BytesReplace;
+
+impl Command for BytesReplace {
+    fn name(&self) -> &str {
+        "bytes replace"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes replace")
+            .required("find", SyntaxShape::Binary, "the pattern to find")
+            .required("replace", SyntaxShape::Binary, "the replacement pattern")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally find and replace text by column paths",
+            )
+            .switch("all", "replace all occurrences of find binary", Some('a'))
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Find and replace binary"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["search", "shift", "switch"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 2)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let find = call.req::<Spanned<Vec<u8>>>(engine_state, stack, 0)?;
+        if find.item.is_empty() {
+            return Err(ShellError::UnsupportedInput(
+                "the pattern to find cannot be empty".to_string(),
+                find.span,
+            ));
+        }
+
+        let arg = Arguments {
+            find: find.item,
+            replace: call.req::<Vec<u8>>(engine_state, stack, 1)?,
+            column_paths,
+            all: call.has_flag("all"),
+        };
+
+        operate(replace, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Find and replace contents",
+                example: "0x[10 AA FF AA FF] | bytes replace 0x[10 AA] 0x[FF]",
+                result: Some(Value::Binary {
+                    val: vec![0xFF, 0xFF, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Find and replace all occurrences of find binary",
+                example: "0x[10 AA 10 BB 10] | bytes replace -a 0x[10] 0x[A0]",
+                result: Some(Value::Binary {
+                    val: vec![0xA0, 0xAA, 0xA0, 0xBB, 0xA0],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Find and replace all occurrences of find binary in table",
+                example: "[[ColA ColB ColC]; [0x[11 12 13] 0x[14 15 16] 0x[17 18 19]]] | bytes replace -a 0x[11] 0x[13] ColA ColC",
+                result: Some(Value::List {
+                    vals: vec![Value::Record {
+                        cols: vec!["ColA".to_string(), "ColB".to_string(), "ColC".to_string()],
+                        vals: vec![
+                            Value::Binary {
+                                val: vec![0x13, 0x12, 0x13],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x14, 0x15, 0x16],
+                                span: Span::test_data(),
+                            },
+                            Value::Binary {
+                                val: vec![0x17, 0x18, 0x19],
+                                span: Span::test_data(),
+                            },
+                        ],
+                        span: Span::test_data(),
+                    }],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn replace(input: &[u8], arg: &Arguments, span: Span) -> Value {
+    let mut replaced = vec![];
+    let replace_all = arg.all;
+
+    // doing find-and-replace stuff.
+    let (mut left, mut right) = (0, arg.find.len());
+    let input_len = input.len();
+    let pattern_len = arg.find.len();
+    while right <= input_len {
+        if input[left..right] == arg.find {
+            let mut to_replace = arg.replace.clone();
+            replaced.append(&mut to_replace);
+            left += pattern_len;
+            right += pattern_len;
+            if !replace_all {
+                break;
+            }
+        } else {
+            replaced.push(input[left]);
+            left += 1;
+            right += 1;
+        }
+    }
+
+    let mut remain = input[left..].to_vec();
+    replaced.append(&mut remain);
+    Value::Binary {
+        val: replaced,
+        span,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesReplace {})
+    }
+}

crates/nu-command/src/bytes/reverse.rs

@@ -0,0 +1,104 @@
+use super::{operate, BytesArgument};
+use nu_engine::CallExt;
+use nu_protocol::ast::Call;
+use nu_protocol::ast::CellPath;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::Category;
+use nu_protocol::{Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value};
+
+struct Arguments {
+    column_paths: Option<Vec<CellPath>>,
+}
+
+impl BytesArgument for Arguments {
+    fn take_column_paths(&mut self) -> Option<Vec<CellPath>> {
+        self.column_paths.take()
+    }
+}
+
+#[derive(Clone)]
+
+pub struct BytesReverse;
+
+impl Command for BytesReverse {
+    fn name(&self) -> &str {
+        "bytes reverse"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("bytes reverse")
+            .rest(
+                "rest",
+                SyntaxShape::CellPath,
+                "optionally matches prefix of text by column paths",
+            )
+            .category(Category::Bytes)
+    }
+
+    fn usage(&self) -> &str {
+        "Reverse every bytes in the pipeline"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["convert", "inverse", "flip"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let column_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
+        let column_paths = if column_paths.is_empty() {
+            None
+        } else {
+            Some(column_paths)
+        };
+        let arg = Arguments { column_paths };
+        operate(reverse, arg, input, call.head, engine_state.ctrlc.clone())
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Reverse bytes `0x[1F FF AA AA]`",
+                example: "0x[1F FF AA AA] | bytes reverse",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xAA, 0xFF, 0x1F],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Reverse bytes `0x[FF AA AA]`",
+                example: "0x[FF AA AA] | bytes reverse",
+                result: Some(Value::Binary {
+                    val: vec![0xAA, 0xAA, 0xFF],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn reverse(input: &[u8], _args: &Arguments, span: Span) -> Value {
+    let mut reversed_input = input.to_vec();
+    reversed_input.reverse();
+    Value::Binary {
+        val: reversed_input,
+        span,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(BytesReverse {})
+    }
+}

crates/nu-command/src/conversions/into/duration.rs

@@ -28,6 +28,10 @@ impl Command for SubCommand {
         "Convert value to duration"
     }
 
+    fn extra_usage(&self) -> &str {
+        "into duration does not take leap years into account and every month is calculated with 30 days"
+    }
+
     fn search_terms(&self) -> Vec<&str> {
         vec!["convert", "time", "period"]
     }
@@ -136,7 +140,7 @@ fn into_duration(
     )
 }
 
-fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
+fn string_to_duration(s: &str, span: Span, value_span: Span) -> Result<i64, ShellError> {
     if let Some(expression) = parse_duration_bytes(s.as_bytes(), span) {
         if let Expr::ValueWithUnit(value, unit) = expression.expr {
             if let Expr::Int(x) = value.expr {
@@ -149,16 +153,21 @@ fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
                     Unit::Hour => return Ok(x * 60 * 60 * 1000 * 1000 * 1000),
                     Unit::Day => return Ok(x * 24 * 60 * 60 * 1000 * 1000 * 1000),
                     Unit::Week => return Ok(x * 7 * 24 * 60 * 60 * 1000 * 1000 * 1000),
+                    Unit::Month => return Ok(x * 30 * 24 * 60 * 60 * 1000 * 1000 * 1000), //30 days to a month
+                    Unit::Year => return Ok(x * 365 * 24 * 60 * 60 * 1000 * 1000 * 1000), //365 days to a year
+                    Unit::Decade => return Ok(x * 10 * 365 * 24 * 60 * 60 * 1000 * 1000 * 1000), //365 days to a year
                     _ => {}
                 }
             }
         }
     }
 
-    Err(ShellError::CantConvert(
+    Err(ShellError::CantConvertWithValue(
         "duration".to_string(),
         "string".to_string(),
+        s.to_string(),
         span,
+        value_span,
         Some("supported units are ns, us, ms, sec, min, hr, day, and wk".to_string()),
     ))
 }
@@ -166,7 +175,10 @@ fn string_to_duration(s: &str, span: Span) -> Result<i64, ShellError> {
 fn action(input: &Value, span: Span) -> Value {
     match input {
         Value::Duration { .. } => input.clone(),
-        Value::String { val, .. } => match string_to_duration(val, span) {
+        Value::String {
+            val,
+            span: value_span,
+        } => match string_to_duration(val, span, *value_span) {
             Ok(val) => Value::Duration { val, span },
             Err(error) => Value::Error { error },
         },

crates/nu-command/src/conversions/into/int.rs

@@ -102,6 +102,21 @@ impl Command for SubCommand {
                 example: "'FF' |  into int -r 16",
                 result: Some(Value::test_int(255)),
             },
+            Example {
+                description: "Convert octal string to integer",
+                example: "'0o10132' | into int",
+                result: Some(Value::test_int(4186)),
+            },
+            Example {
+                description: "Convert 0 padded string to integer",
+                example: "'0010132' | into int",
+                result: Some(Value::test_int(10132)),
+            },
+            Example {
+                description: "Convert 0 padded string to integer with radix",
+                example: "'0010132' | into int -r 8",
+                result: Some(Value::test_int(4186)),
+            },
         ]
     }
 }
@@ -169,7 +184,32 @@ pub fn action(input: &Value, span: Span, radix: u32, little_endian: bool) -> Val
         }
         Value::Filesize { val, .. } => Value::Int { val: *val, span },
         Value::Float { val, .. } => Value::Int {
-            val: *val as i64,
+            val: {
+                if radix == 10 {
+                    *val as i64
+                } else {
+                    match convert_int(
+                        &Value::Int {
+                            val: *val as i64,
+                            span,
+                        },
+                        span,
+                        radix,
+                    )
+                    .as_i64()
+                    {
+                        Ok(v) => v,
+                        _ => {
+                            return Value::Error {
+                                error: ShellError::UnsupportedInput(
+                                    "Could not convert float to integer".to_string(),
+                                    span,
+                                ),
+                            }
+                        }
+                    }
+                }
+            },
             span,
         },
         Value::String { val, .. } => {
@@ -233,11 +273,31 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
     let i = match input {
         Value::Int { val, .. } => val.to_string(),
         Value::String { val, .. } => {
-            if val.starts_with("0x") || val.starts_with("0b") {
+            let val = val.trim();
+            if val.starts_with("0x") // hex
+                || val.starts_with("0b") // binary
+                || val.starts_with("0o")
+            // octal
+            {
                 match int_from_string(val, head) {
                     Ok(x) => return Value::Int { val: x, span: head },
                     Err(e) => return Value::Error { error: e },
                 }
+            } else if val.starts_with("00") {
+                // It's a padded string
+                match i64::from_str_radix(val, radix) {
+                    Ok(n) => return Value::Int { val: n, span: head },
+                    Err(e) => {
+                        return Value::Error {
+                            error: ShellError::CantConvert(
+                                "string".to_string(),
+                                "int".to_string(),
+                                head,
+                                Some(e.to_string()),
+                            ),
+                        }
+                    }
+                }
             }
             val.to_string()
         }
@@ -250,10 +310,10 @@ fn convert_int(input: &Value, head: Span, radix: u32) -> Value {
             }
         }
     };
-    match i64::from_str_radix(&i, radix) {
+    match i64::from_str_radix(i.trim(), radix) {
         Ok(n) => Value::Int { val: n, span: head },
         Err(_reason) => Value::Error {
-            error: ShellError::CantConvert("int".to_string(), "string".to_string(), head, None),
+            error: ShellError::CantConvert("string".to_string(), "int".to_string(), head, None),
         },
     }
 }
@@ -291,7 +351,21 @@ fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
                 };
             Ok(num)
         }
-        _ => match a_string.parse::<i64>() {
+        o if o.starts_with("0o") => {
+            let num = match i64::from_str_radix(o.trim_start_matches("0o"), 8) {
+                Ok(n) => n,
+                Err(_reason) => {
+                    return Err(ShellError::CantConvert(
+                        "int".to_string(),
+                        "string".to_string(),
+                        span,
+                        Some(r#"octal digits following "0o" should be in 0-7"#.to_string()),
+                    ))
+                }
+            };
+            Ok(num)
+        }
+        _ => match trimmed.parse::<i64>() {
             Ok(n) => Ok(n),
             Err(_) => match a_string.parse::<f64>() {
                 Ok(f) => Ok(f as i64),
@@ -299,7 +373,10 @@ fn int_from_string(a_string: &str, span: Span) -> Result<i64, ShellError> {
                     "int".to_string(),
                     "string".to_string(),
                     span,
-                    None,
+                    Some(format!(
+                        r#"string "{}" does not represent a valid integer"#,
+                        trimmed
+                    )),
                 )),
             },
         },

crates/nu-command/src/conversions/into/string.rs

@@ -53,6 +53,14 @@ impl Command for SubCommand {
 
     fn examples(&self) -> Vec<Example> {
         vec![
+            Example {
+                description: "convert integer to string and append three decimal places",
+                example: "5 | into string -d 3",
+                result: Some(Value::String {
+                    val: "5.000".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
             Example {
                 description: "convert decimal to string and round to nearest integer",
                 example: "1.7 | into string -d 0",
@@ -210,6 +218,15 @@ pub fn action(
         Value::Int { val, .. } => {
             let res = if group_digits {
                 format_int(*val) // int.to_formatted_string(*locale)
+            } else if let Some(dig) = digits {
+                let mut val_with_trailing_zeroes = val.to_string();
+                if dig != 0 {
+                    val_with_trailing_zeroes.push('.');
+                }
+                for _ in 0..dig {
+                    val_with_trailing_zeroes.push('0');
+                }
+                val_with_trailing_zeroes
             } else {
                 val.to_string()
             };

crates/nu-command/src/core_commands/error_make.rs

@@ -16,6 +16,11 @@ impl Command for ErrorMake {
     fn signature(&self) -> Signature {
         Signature::build("error make")
             .required("error_struct", SyntaxShape::Record, "the error to create")
+            .switch(
+                "unspanned",
+                "remove the origin label from the error",
+                Some('u'),
+            )
             .category(Category::Core)
     }
 
@@ -36,16 +41,29 @@ impl Command for ErrorMake {
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
         let span = call.head;
         let arg: Value = call.req(engine_state, stack, 0)?;
+        let unspanned = call.has_flag("unspanned");
 
-        Err(make_error(&arg, span).unwrap_or_else(|| {
-            ShellError::GenericError(
-                "Creating error value not supported.".into(),
-                "unsupported error format".into(),
-                Some(span),
-                None,
-                Vec::new(),
-            )
-        }))
+        if unspanned {
+            Err(make_error(&arg, None).unwrap_or_else(|| {
+                ShellError::GenericError(
+                    "Creating error value not supported.".into(),
+                    "unsupported error format".into(),
+                    Some(span),
+                    None,
+                    Vec::new(),
+                )
+            }))
+        } else {
+            Err(make_error(&arg, Some(span)).unwrap_or_else(|| {
+                ShellError::GenericError(
+                    "Creating error value not supported.".into(),
+                    "unsupported error format".into(),
+                    Some(span),
+                    None,
+                    Vec::new(),
+                )
+            }))
+        }
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -69,7 +87,7 @@ impl Command for ErrorMake {
     }
 }
 
-fn make_error(value: &Value, throw_span: Span) -> Option<ShellError> {
+fn make_error(value: &Value, throw_span: Option<Span>) -> Option<ShellError> {
     if let Value::Record { .. } = &value {
         let msg = value.get_data_by_key("msg");
         let label = value.get_data_by_key("label");
@@ -106,7 +124,7 @@ fn make_error(value: &Value, throw_span: Span) -> Option<ShellError> {
                     ) => Some(ShellError::GenericError(
                         message,
                         label_text,
-                        Some(throw_span),
+                        throw_span,
                         None,
                         Vec::new(),
                     )),
@@ -116,7 +134,7 @@ fn make_error(value: &Value, throw_span: Span) -> Option<ShellError> {
             (Some(Value::String { val: message, .. }), None) => Some(ShellError::GenericError(
                 message,
                 "originates from here".to_string(),
-                Some(throw_span),
+                throw_span,
                 None,
                 Vec::new(),
             )),

crates/nu-command/src/core_commands/help.rs

@@ -1,12 +1,15 @@
+use nu_ansi_term::{
+    Color::{Default, Red, White},
+    Style,
+};
+use nu_color_config::get_color_config;
+use nu_engine::{get_full_help, CallExt};
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
     span, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData,
-    ShellError, Signature, Spanned, SyntaxShape, Value,
+    ShellError, Signature, Span, Spanned, SyntaxShape, Value,
 };
-
-use nu_engine::{get_full_help, CallExt};
-
 use std::borrow::Borrow;
 
 #[derive(Clone)]
@@ -81,23 +84,29 @@ fn help(
     let head = call.head;
     let find: Option<Spanned<String>> = call.get_flag(engine_state, stack, "find")?;
     let rest: Vec<Spanned<String>> = call.rest(engine_state, stack, 0)?;
-
     let commands = engine_state.get_decl_ids_sorted(false);
+    let config = engine_state.get_config();
+    let color_hm = get_color_config(config);
+    let default_style = Style::new().fg(Default).on(Default);
+    let string_style = match color_hm.get("string") {
+        Some(style) => style,
+        None => &default_style,
+    };
 
     if let Some(f) = find {
+        let org_search_string = f.item.clone();
         let search_string = f.item.to_lowercase();
         let mut found_cmds_vec = Vec::new();
 
         for decl_id in commands {
             let mut cols = vec![];
             let mut vals = vec![];
-
             let decl = engine_state.get_decl(decl_id);
             let sig = decl.signature().update_from_command(decl.borrow());
-
             let key = sig.name;
             let usage = sig.usage;
             let search_terms = sig.search_terms;
+
             let matches_term = if !search_terms.is_empty() {
                 search_terms
                     .iter()
@@ -106,13 +115,16 @@ fn help(
                 false
             };
 
-            if key.to_lowercase().contains(&search_string)
-                || usage.to_lowercase().contains(&search_string)
-                || matches_term
-            {
+            let key_match = key.to_lowercase().contains(&search_string);
+            let usage_match = usage.to_lowercase().contains(&search_string);
+            if key_match || usage_match || matches_term {
                 cols.push("name".into());
                 vals.push(Value::String {
-                    val: key,
+                    val: if key_match {
+                        highlight_search_string(&key, &org_search_string, string_style)?
+                    } else {
+                        key
+                    },
                     span: head,
                 });
 
@@ -142,7 +154,11 @@ fn help(
 
                 cols.push("usage".into());
                 vals.push(Value::String {
-                    val: usage,
+                    val: if usage_match {
+                        highlight_search_string(&usage, &org_search_string, string_style)?
+                    } else {
+                        usage
+                    },
                     span: head,
                 });
 
@@ -151,7 +167,30 @@ fn help(
                     Value::nothing(head)
                 } else {
                     Value::String {
-                        val: search_terms.join(", "),
+                        val: if matches_term {
+                            search_terms
+                                .iter()
+                                .map(|term| {
+                                    if term.to_lowercase().contains(&search_string) {
+                                        match highlight_search_string(
+                                            term,
+                                            &org_search_string,
+                                            string_style,
+                                        ) {
+                                            Ok(s) => s,
+                                            Err(_) => {
+                                                string_style.paint(term.to_string()).to_string()
+                                            }
+                                        }
+                                    } else {
+                                        string_style.paint(term.to_string()).to_string()
+                                    }
+                                })
+                                .collect::<Vec<_>>()
+                                .join(", ")
+                        } else {
+                            search_terms.join(", ")
+                        },
                         span: head,
                     }
                 });
@@ -303,3 +342,48 @@ You can also learn more at https://www.nushell.sh/book/"#;
         .into_pipeline_data())
     }
 }
+
+// Highlight the search string using ANSI escape sequences and regular expressions.
+pub fn highlight_search_string(
+    haystack: &str,
+    needle: &str,
+    string_style: &Style,
+) -> Result<String, ShellError> {
+    let regex_string = format!("(?i){}", needle);
+    let regex = match regex::Regex::new(&regex_string) {
+        Ok(regex) => regex,
+        Err(err) => {
+            return Err(ShellError::GenericError(
+                "Could not compile regex".into(),
+                err.to_string(),
+                Some(Span::test_data()),
+                None,
+                Vec::new(),
+            ));
+        }
+    };
+    let mut last_match_end = 0;
+    let style = Style::new().fg(White).on(Red);
+    let mut highlighted = String::new();
+
+    for cap in regex.captures_iter(haystack) {
+        let start = match cap.get(0) {
+            Some(cap) => cap.start(),
+            None => 0,
+        };
+        let end = match cap.get(0) {
+            Some(cap) => cap.end(),
+            None => 0,
+        };
+        highlighted.push_str(
+            &string_style
+                .paint(&haystack[last_match_end..start])
+                .to_string(),
+        );
+        highlighted.push_str(&style.paint(&haystack[start..end]).to_string());
+        last_match_end = end;
+    }
+
+    highlighted.push_str(&string_style.paint(&haystack[last_match_end..]).to_string());
+    Ok(highlighted)
+}

crates/nu-command/src/core_commands/if_.rs

@@ -92,6 +92,7 @@ impl Command for If {
                                 call.redirect_stdout,
                                 call.redirect_stderr,
                             )
+                            .map(|res| res.0)
                         }
                     } else {
                         eval_expression_with_input(
@@ -102,6 +103,7 @@ impl Command for If {
                             call.redirect_stdout,
                             call.redirect_stderr,
                         )
+                        .map(|res| res.0)
                     }
                 } else {
                     Ok(PipelineData::new(call.head))

crates/nu-command/src/core_commands/let_.rs

@@ -35,6 +35,10 @@ impl Command for Let {
         true
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["set", "const"]
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -61,7 +65,8 @@ impl Command for Let {
             input,
             call.redirect_stdout,
             call.redirect_stderr,
-        )?;
+        )?
+        .0;
 
         //println!("Adding: {:?} to {}", rhs, var_id);
 

crates/nu-command/src/core_commands/mod.rs

@@ -14,7 +14,7 @@ mod export_env;
 mod export_extern;
 mod extern_;
 mod for_;
-mod help;
+pub mod help;
 mod hide;
 mod if_;
 mod ignore;

crates/nu-command/src/core_commands/overlay/remove.rs

@@ -1,9 +1,7 @@
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
-use nu_protocol::{
-    Category, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape, Value,
-};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Spanned, SyntaxShape};
 
 #[derive(Clone)]
 pub struct OverlayRemove;
@@ -22,9 +20,15 @@ impl Command for OverlayRemove {
             .optional("name", SyntaxShape::String, "Overlay to remove")
             .switch(
                 "keep-custom",
-                "Keep newly added symbols within the next activated overlay",
+                "Keep all newly added symbols within the next activated overlay",
                 Some('k'),
             )
+            .named(
+                "keep-env",
+                SyntaxShape::List(Box::new(SyntaxShape::String)),
+                "List of environment variables to keep from the removed overlay",
+                Some('e'),
+            )
             .category(Category::Core)
     }
 
@@ -60,30 +64,44 @@ impl Command for OverlayRemove {
             ));
         }
 
-        if call.has_flag("keep-custom") {
+        let keep_env: Option<Vec<Spanned<String>>> =
+            call.get_flag(engine_state, stack, "keep-env")?;
+
+        let env_vars_to_keep = if call.has_flag("keep-custom") {
             if let Some(overlay_id) = engine_state.find_overlay(overlay_name.item.as_bytes()) {
                 let overlay_frame = engine_state.get_overlay(overlay_id);
                 let origin_module = engine_state.get_module(overlay_frame.origin);
 
-                let env_vars_to_keep: Vec<(String, Value)> = stack
+                stack
                     .get_overlay_env_vars(engine_state, &overlay_name.item)
                     .into_iter()
                     .filter(|(name, _)| !origin_module.has_env_var(name.as_bytes()))
-                    .collect();
-
-                stack.remove_overlay(&overlay_name.item);
-
-                for (name, val) in env_vars_to_keep {
-                    stack.add_env_var(name, val);
-                }
+                    .collect()
             } else {
                 return Err(ShellError::OverlayNotFoundAtRuntime(
                     overlay_name.item,
                     overlay_name.span,
                 ));
             }
+        } else if let Some(env_var_names_to_keep) = keep_env {
+            let mut env_vars_to_keep = vec![];
+
+            for name in env_var_names_to_keep.into_iter() {
+                match stack.get_env_var(engine_state, &name.item) {
+                    Some(val) => env_vars_to_keep.push((name.item, val.clone())),
+                    None => return Err(ShellError::EnvVarNotFoundAtRuntime(name.item, name.span)),
+                }
+            }
+
+            env_vars_to_keep
         } else {
-            stack.remove_overlay(&overlay_name.item);
+            vec![]
+        };
+
+        stack.remove_overlay(&overlay_name.item);
+
+        for (name, val) in env_vars_to_keep {
+            stack.add_env_var(name, val);
         }
 
         Ok(PipelineData::new(call.head))
@@ -112,6 +130,13 @@ impl Command for OverlayRemove {
     overlay remove"#,
                 result: None,
             },
+            Example {
+                description: "Keep the current working directory when removing an overlay",
+                example: r#"overlay new spam
+    cd some-dir
+    overlay remove --keep-env [ PWD ] spam"#,
+                result: None,
+            },
         ]
     }
 }

crates/nu-command/src/core_commands/source.rs

@@ -69,11 +69,6 @@ impl Command for Source {
                 example: r#"source ./foo.nu; say-hi"#,
                 result: None,
             },
-            Example {
-                description: "Runs foo.nu in current context and call the `main` command automatically, suppose foo.nu has content: `def main [] { echo 'Hi!' }`",
-                example: r#"source ./foo.nu"#,
-                result: None,
-            },
         ]
     }
 }

crates/nu-command/src/database/test_database.rs

@@ -75,8 +75,9 @@ pub fn test_database(cmds: Vec<Box<dyn Command + 'static>>) {
         working_set.render()
     };
 
-    let cwd = std::env::current_dir().expect("Could not get current working directory.");
-    let _ = engine_state.merge_delta(delta, None, &cwd);
+    engine_state
+        .merge_delta(delta)
+        .expect("Error merging delta");
 
     for example in examples {
         // Skip tests that don't have results to compare to
@@ -102,7 +103,9 @@ pub fn test_database(cmds: Vec<Box<dyn Command + 'static>>) {
             (output, working_set.render())
         };
 
-        let _ = engine_state.merge_delta(delta, None, &cwd);
+        engine_state
+            .merge_delta(delta)
+            .expect("Error merging delta");
 
         let mut stack = Stack::new();
 

crates/nu-command/src/dataframe/expressions/concat_str.rs

@@ -0,0 +1,106 @@
+use crate::dataframe::values::{Column, NuDataFrame, NuExpression};
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
+};
+use polars::prelude::concat_str;
+
+#[derive(Clone)]
+pub struct ExprConcatStr;
+
+impl Command for ExprConcatStr {
+    fn name(&self) -> &str {
+        "concat-str"
+    }
+
+    fn usage(&self) -> &str {
+        "Creates a concat string expression"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .required(
+                "separator",
+                SyntaxShape::String,
+                "Separator used during the concatenation",
+            )
+            .required(
+                "concat expressions",
+                SyntaxShape::List(Box::new(SyntaxShape::Any)),
+                "Expression(s) that define the string concatenation",
+            )
+            .input_type(Type::Any)
+            .output_type(Type::Custom("expression".into()))
+            .category(Category::Custom("expression".into()))
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "Creates a concat string expression",
+            example: r#"let df = ([[a b c]; [one two 1] [three four 2]] | into df);
+    $df | with-column ((concat-str "-" [(col a) (col b) ((col c) * 2)]) | as concat)"#,
+            result: Some(
+                NuDataFrame::try_from_columns(vec![
+                    Column::new(
+                        "a".to_string(),
+                        vec![Value::test_string("one"), Value::test_string("three")],
+                    ),
+                    Column::new(
+                        "b".to_string(),
+                        vec![Value::test_string("two"), Value::test_string("four")],
+                    ),
+                    Column::new(
+                        "c".to_string(),
+                        vec![Value::test_int(1), Value::test_int(2)],
+                    ),
+                    Column::new(
+                        "concat".to_string(),
+                        vec![
+                            Value::test_string("one-two-2"),
+                            Value::test_string("three-four-4"),
+                        ],
+                    ),
+                ])
+                .expect("simple df for test should not fail")
+                .into_value(Span::test_data()),
+            ),
+        }]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let separator: String = call.req(engine_state, stack, 0)?;
+        let value: Value = call.req(engine_state, stack, 1)?;
+
+        let expressions = NuExpression::extract_exprs(value)?;
+        let expr: NuExpression = concat_str(expressions, &separator).into();
+
+        Ok(PipelineData::Value(expr.into_value(call.head), None))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::super::super::test_dataframe::test_dataframe;
+    use super::*;
+    use crate::dataframe::eager::WithColumn;
+    use crate::dataframe::expressions::alias::ExprAlias;
+    use crate::dataframe::expressions::col::ExprCol;
+
+    #[test]
+    fn test_examples() {
+        test_dataframe(vec![
+            Box::new(ExprConcatStr {}),
+            Box::new(ExprAlias {}),
+            Box::new(ExprCol {}),
+            Box::new(WithColumn {}),
+        ])
+    }
+}

crates/nu-command/src/dataframe/expressions/mod.rs

@@ -1,6 +1,7 @@
 mod alias;
 mod as_nu;
 mod col;
+mod concat_str;
 mod expressions_macro;
 mod lit;
 mod otherwise;
@@ -12,6 +13,7 @@ use nu_protocol::engine::StateWorkingSet;
 pub(crate) use crate::dataframe::expressions::alias::ExprAlias;
 use crate::dataframe::expressions::as_nu::ExprAsNu;
 pub(super) use crate::dataframe::expressions::col::ExprCol;
+pub(super) use crate::dataframe::expressions::concat_str::ExprConcatStr;
 pub(crate) use crate::dataframe::expressions::expressions_macro::*;
 pub(super) use crate::dataframe::expressions::lit::ExprLit;
 pub(super) use crate::dataframe::expressions::otherwise::ExprOtherwise;
@@ -32,6 +34,7 @@ pub fn add_expressions(working_set: &mut StateWorkingSet) {
     bind_command!(
         ExprAlias,
         ExprCol,
+        ExprConcatStr,
         ExprCount,
         ExprLit,
         ExprAsNu,

crates/nu-command/src/dataframe/lazy/aggregate.rs

@@ -6,6 +6,7 @@ use nu_protocol::{
     engine::{Command, EngineState, Stack},
     Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
 };
+use polars::{datatypes::DataType, prelude::Expr};
 
 #[derive(Clone)]
 pub struct LazyAggregate;
@@ -118,12 +119,29 @@ impl Command for LazyAggregate {
         let expressions = NuExpression::extract_exprs(value)?;
 
         let group_by = NuLazyGroupBy::try_from_pipeline(input, call.head)?;
-        let from_eager = group_by.from_eager;
 
-        let group_by = group_by.into_polars();
+        if let Some(schema) = &group_by.schema {
+            for expr in &expressions {
+                if let Some(name) = get_col_name(expr) {
+                    let dtype = schema.get(name.as_str());
+
+                    if matches!(dtype, Some(DataType::Object(..))) {
+                        return Err(ShellError::GenericError(
+                            "Object type column not supported for aggregation".into(),
+                            format!("Column '{}' is type Object", name),
+                            Some(call.head),
+                            Some("Aggregations cannot be performed on Object type columns. Use dtype command to check column types".into()),
+                            Vec::new(),
+                        ));
+                    }
+                }
+            }
+        }
+
         let lazy = NuLazyFrame {
-            lazy: group_by.agg(&expressions).into(),
-            from_eager,
+            from_eager: group_by.from_eager,
+            lazy: Some(group_by.into_polars().agg(&expressions)),
+            schema: None,
         };
 
         let res = lazy.into_value(call.head)?;
@@ -131,6 +149,57 @@ impl Command for LazyAggregate {
     }
 }
 
+fn get_col_name(expr: &Expr) -> Option<String> {
+    match expr {
+        Expr::Column(column) => Some(column.to_string()),
+        Expr::Agg(agg) => match agg {
+            polars::prelude::AggExpr::Min(e)
+            | polars::prelude::AggExpr::Max(e)
+            | polars::prelude::AggExpr::Median(e)
+            | polars::prelude::AggExpr::NUnique(e)
+            | polars::prelude::AggExpr::First(e)
+            | polars::prelude::AggExpr::Last(e)
+            | polars::prelude::AggExpr::Mean(e)
+            | polars::prelude::AggExpr::List(e)
+            | polars::prelude::AggExpr::Count(e)
+            | polars::prelude::AggExpr::Sum(e)
+            | polars::prelude::AggExpr::AggGroups(e)
+            | polars::prelude::AggExpr::Std(e)
+            | polars::prelude::AggExpr::Var(e) => get_col_name(e.as_ref()),
+            polars::prelude::AggExpr::Quantile { expr, .. } => get_col_name(expr.as_ref()),
+        },
+        Expr::Reverse(expr)
+        | Expr::Shift { input: expr, .. }
+        | Expr::Filter { input: expr, .. }
+        | Expr::Slice { input: expr, .. }
+        | Expr::Cast { expr, .. }
+        | Expr::Sort { expr, .. }
+        | Expr::Take { expr, .. }
+        | Expr::SortBy { expr, .. }
+        | Expr::Exclude(expr, _)
+        | Expr::Alias(expr, _)
+        | Expr::KeepName(expr)
+        | Expr::Not(expr)
+        | Expr::IsNotNull(expr)
+        | Expr::IsNull(expr)
+        | Expr::Duplicated(expr)
+        | Expr::IsUnique(expr)
+        | Expr::Explode(expr) => get_col_name(expr.as_ref()),
+        Expr::Ternary { .. }
+        | Expr::AnonymousFunction { .. }
+        | Expr::Function { .. }
+        | Expr::Columns(_)
+        | Expr::DtypeColumn(_)
+        | Expr::Literal(_)
+        | Expr::BinaryExpr { .. }
+        | Expr::Window { .. }
+        | Expr::Wildcard
+        | Expr::RenameAlias { .. }
+        | Expr::Count
+        | Expr::Nth(_) => None,
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::super::super::test_dataframe::test_dataframe;

crates/nu-command/src/dataframe/lazy/groupby.rs

@@ -128,13 +128,11 @@ impl Command for ToLazyGroupBy {
             ));
         }
 
-        let value = input.into_value(call.head);
-        let lazy = NuLazyFrame::try_from_value(value)?;
-        let from_eager = lazy.from_eager;
-
+        let lazy = NuLazyFrame::try_from_pipeline(input, call.head)?;
         let group_by = NuLazyGroupBy {
+            schema: lazy.schema.clone(),
+            from_eager: lazy.from_eager,
             group_by: Some(lazy.into_polars().groupby(&expressions)),
-            from_eager,
         };
 
         Ok(PipelineData::Value(group_by.into_value(call.head), None))

crates/nu-command/src/dataframe/test_dataframe.rs

@@ -37,8 +37,9 @@ pub fn test_dataframe(cmds: Vec<Box<dyn Command + 'static>>) {
         working_set.render()
     };
 
-    let cwd = std::env::current_dir().expect("Could not get current working directory.");
-    let _ = engine_state.merge_delta(delta, None, &cwd);
+    engine_state
+        .merge_delta(delta)
+        .expect("Error merging delta");
 
     for example in examples {
         // Skip tests that don't have results to compare to
@@ -64,7 +65,9 @@ pub fn test_dataframe(cmds: Vec<Box<dyn Command + 'static>>) {
             (output, working_set.render())
         };
 
-        let _ = engine_state.merge_delta(delta, None, &cwd);
+        engine_state
+            .merge_delta(delta)
+            .expect("Error merging delta");
 
         let mut stack = Stack::new();
 

crates/nu-command/src/dataframe/values/nu_dataframe/between_values.rs

@@ -226,6 +226,7 @@ pub(super) fn compute_series_single_value(
             Value::Float { val, .. } => {
                 compute_series_decimal(&lhs, *val, <ChunkedArray<Float64Type>>::add, lhs_span)
             }
+            Value::String { val, .. } => add_string_to_series(&lhs, val, lhs_span),
             _ => Err(ShellError::OperatorMismatch {
                 op_span: operator.span,
                 lhs_ty: left.get_type(),
@@ -758,3 +759,22 @@ fn contains_series_pat(series: &Series, pat: &str, span: Span) -> Result<Value,
         )),
     }
 }
+
+fn add_string_to_series(series: &Series, pat: &str, span: Span) -> Result<Value, ShellError> {
+    let casted = series.utf8();
+    match casted {
+        Ok(casted) => {
+            let res = casted + pat;
+            let res = res.into_series();
+
+            NuDataFrame::series_to_value(res, span)
+        }
+        Err(e) => Err(ShellError::GenericError(
+            "Unable to cast to string".into(),
+            e.to_string(),
+            Some(span),
+            None,
+            Vec::new(),
+        )),
+    }
+}

crates/nu-command/src/dataframe/values/nu_lazyframe/custom_value.rs

@@ -15,6 +15,7 @@ impl CustomValue for NuLazyFrame {
         let cloned = NuLazyFrame {
             lazy: self.lazy.clone(),
             from_eager: self.from_eager,
+            schema: self.schema.clone(),
         };
 
         Value::CustomValue {

crates/nu-command/src/dataframe/values/nu_lazyframe/mod.rs

@@ -3,7 +3,7 @@ mod custom_value;
 use super::{NuDataFrame, NuExpression};
 use core::fmt;
 use nu_protocol::{PipelineData, ShellError, Span, Value};
-use polars::prelude::{Expr, IntoLazy, LazyFrame};
+use polars::prelude::{Expr, IntoLazy, LazyFrame, Schema};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 // Lazyframe wrapper for Nushell operations
@@ -12,6 +12,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[derive(Default)]
 pub struct NuLazyFrame {
     pub lazy: Option<LazyFrame>,
+    pub schema: Option<Schema>,
     pub from_eager: bool,
 }
 
@@ -63,6 +64,7 @@ impl From<LazyFrame> for NuLazyFrame {
         Self {
             lazy: Some(lazy_frame),
             from_eager: false,
+            schema: None,
         }
     }
 }
@@ -72,6 +74,7 @@ impl NuLazyFrame {
         Self {
             lazy: Some(lazy),
             from_eager,
+            schema: None,
         }
     }
 
@@ -80,6 +83,7 @@ impl NuLazyFrame {
         Self {
             lazy: Some(lazy),
             from_eager: true,
+            schema: Some(df.as_ref().schema()),
         }
     }
 
@@ -148,6 +152,7 @@ impl NuLazyFrame {
                 Some(expr) => Ok(Self {
                     lazy: expr.lazy.clone(),
                     from_eager: false,
+                    schema: None,
                 }),
                 None => Err(ShellError::CantConvert(
                     "lazy frame".into(),
@@ -184,6 +189,7 @@ impl NuLazyFrame {
         Self {
             from_eager: self.from_eager,
             lazy: Some(new_frame),
+            schema: None,
         }
     }
 }

crates/nu-command/src/dataframe/values/nu_lazygroupby/custom_value.rs

@@ -14,6 +14,7 @@ impl CustomValue for NuLazyGroupBy {
     fn clone_value(&self, span: nu_protocol::Span) -> Value {
         let cloned = NuLazyGroupBy {
             group_by: self.group_by.clone(),
+            schema: self.schema.clone(),
             from_eager: self.from_eager,
         };
 

crates/nu-command/src/dataframe/values/nu_lazygroupby/mod.rs

@@ -2,7 +2,7 @@ mod custom_value;
 
 use core::fmt;
 use nu_protocol::{PipelineData, ShellError, Span, Value};
-use polars::prelude::LazyGroupBy;
+use polars::prelude::{LazyGroupBy, Schema};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 // Lazyframe wrapper for Nushell operations
@@ -11,6 +11,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[derive(Default)]
 pub struct NuLazyGroupBy {
     pub group_by: Option<LazyGroupBy>,
+    pub schema: Option<Schema>,
     pub from_eager: bool,
 }
 
@@ -66,6 +67,7 @@ impl From<LazyGroupBy> for NuLazyGroupBy {
         Self {
             group_by: Some(group_by),
             from_eager: false,
+            schema: None,
         }
     }
 }
@@ -88,6 +90,7 @@ impl NuLazyGroupBy {
                 match val.as_any().downcast_ref::<NuLazyGroupBy>() {
                     Some(group) => Ok(Self {
                         group_by: group.group_by.clone(),
+                        schema: group.schema.clone(),
                         from_eager: group.from_eager,
                     }),
                     None => Err(ShellError::CantConvert(

crates/nu-command/src/default_context.rs

@@ -1,10 +1,8 @@
 use nu_protocol::engine::{EngineState, StateWorkingSet};
 
-use std::path::Path;
-
 use crate::*;
 
-pub fn create_default_context(cwd: impl AsRef<Path>) -> EngineState {
+pub fn create_default_context() -> EngineState {
     let mut engine_state = EngineState::new();
 
     let delta = {
@@ -121,6 +119,7 @@ pub fn create_default_context(cwd: impl AsRef<Path>) -> EngineState {
             SkipWhile,
             Sort,
             SortBy,
+            SplitList,
             Transpose,
             Uniq,
             Upsert,
@@ -209,8 +208,18 @@ pub fn create_default_context(cwd: impl AsRef<Path>) -> EngineState {
 
         // Bytes
         bind_command! {
+            Bytes,
             BytesLen,
-            BytesStartsWith
+            BytesStartsWith,
+            BytesEndsWith,
+            BytesReverse,
+            BytesReplace,
+            BytesAdd,
+            BytesAt,
+            BytesIndexOf,
+            BytesCollect,
+            BytesRemove,
+            BytesBuild,
         }
 
         // FileSystem
@@ -333,6 +342,7 @@ pub fn create_default_context(cwd: impl AsRef<Path>) -> EngineState {
             WithEnv,
             ConfigNu,
             ConfigEnv,
+            ConfigReset,
             ConfigMeta,
         };
 
@@ -422,7 +432,9 @@ pub fn create_default_context(cwd: impl AsRef<Path>) -> EngineState {
         working_set.render()
     };
 
-    let _ = engine_state.merge_delta(delta, None, &cwd);
+    if let Err(err) = engine_state.merge_delta(delta) {
+        eprintln!("Error creating default context: {:?}", err);
+    }
 
     engine_state
 }

crates/nu-command/src/env/config/config_reset.rs

@@ -0,0 +1,112 @@
+use chrono::Local;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, Example, PipelineData, ShellError, Signature,
+};
+use std::io::Write;
+
+#[derive(Clone)]
+pub struct ConfigReset;
+
+impl Command for ConfigReset {
+    fn name(&self) -> &str {
+        "config reset"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build(self.name())
+            .switch("nu", "reset only nu config, config.nu", Some('n'))
+            .switch("env", "reset only env config, env.nu", Some('e'))
+            .switch("without-backup", "do not make a backup", Some('w'))
+            .category(Category::Env)
+    }
+
+    fn usage(&self) -> &str {
+        "Reset nushell environment configurations to default, and saves old config files in the config location as oldconfig.nu and oldenv.nu"
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![Example {
+            description: "reset nushell configuration files",
+            example: "config reset",
+            result: None,
+        }]
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let only_nu = call.has_flag("nu");
+        let only_env = call.has_flag("env");
+        let no_backup = call.has_flag("without-backup");
+        let span = call.head;
+        let mut config_path = match nu_path::config_dir() {
+            Some(path) => path,
+            None => {
+                return Err(ShellError::GenericError(
+                    "Could not find config path".to_string(),
+                    "Could not find config path".to_string(),
+                    None,
+                    None,
+                    Vec::new(),
+                ));
+            }
+        };
+        config_path.push("nushell");
+        if !only_env {
+            let mut nu_config = config_path.clone();
+            nu_config.push("config.nu");
+            let config_file = include_str!("../../../../../docs/sample_config/default_config.nu");
+            if !no_backup {
+                let mut backup_path = config_path.clone();
+                backup_path.push(format!(
+                    "oldconfig-{}.nu",
+                    Local::now().format("%F-%H-%M-%S"),
+                ));
+                if std::fs::rename(nu_config.clone(), backup_path).is_err() {
+                    return Err(ShellError::FileNotFoundCustom(
+                        "config.nu could not be backed up".into(),
+                        span,
+                    ));
+                }
+            }
+            if let Ok(mut file) = std::fs::File::create(nu_config) {
+                if writeln!(&mut file, "{}", config_file).is_err() {
+                    return Err(ShellError::FileNotFoundCustom(
+                        "config.nu could not be written to".into(),
+                        span,
+                    ));
+                }
+            }
+        }
+        if !only_nu {
+            let mut env_config = config_path.clone();
+            env_config.push("env.nu");
+            let config_file = include_str!("../../../../../docs/sample_config/default_env.nu");
+            if !no_backup {
+                let mut backup_path = config_path.clone();
+                backup_path.push(format!("oldenv-{}.nu", Local::now().format("%F-%H-%M-%S"),));
+                if std::fs::rename(env_config.clone(), backup_path).is_err() {
+                    return Err(ShellError::FileNotFoundCustom(
+                        "env.nu could not be backed up".into(),
+                        span,
+                    ));
+                }
+            }
+            if let Ok(mut file) = std::fs::File::create(env_config) {
+                if writeln!(&mut file, "{}", config_file).is_err() {
+                    return Err(ShellError::FileNotFoundCustom(
+                        "env.nu could not be written to".into(),
+                        span,
+                    ));
+                }
+            }
+        }
+        Ok(PipelineData::new(span))
+    }
+}

crates/nu-command/src/env/config/mod.rs

@@ -1,7 +1,9 @@
 mod config_;
 mod config_env;
 mod config_nu;
+mod config_reset;
 mod utils;
 pub use config_::ConfigMeta;
 pub use config_env::ConfigEnv;
 pub use config_nu::ConfigNu;
+pub use config_reset::ConfigReset;

crates/nu-command/src/env/let_env.rs

@@ -43,6 +43,7 @@ impl Command for LetEnv {
 
         let rhs =
             eval_expression_with_input(engine_state, stack, keyword_expr, input, false, true)?
+                .0
                 .into_value(call.head);
 
         if env_var == "PWD" {

crates/nu-command/src/env/mod.rs

@@ -7,6 +7,7 @@ mod with_env;
 pub use config::ConfigEnv;
 pub use config::ConfigMeta;
 pub use config::ConfigNu;
+pub use config::ConfigReset;
 pub use env_command::Env;
 pub use let_env::LetEnv;
 pub use load_env::LoadEnv;

crates/nu-command/src/example_test.rs

@@ -57,7 +57,10 @@ pub fn test_examples(cmd: impl Command + 'static) {
     };
 
     let cwd = std::env::current_dir().expect("Could not get current working directory.");
-    let _ = engine_state.merge_delta(delta, None, &cwd);
+
+    engine_state
+        .merge_delta(delta)
+        .expect("Error merging delta");
 
     for example in examples {
         // Skip tests that don't have results to compare to
@@ -76,11 +79,10 @@ pub fn test_examples(cmd: impl Command + 'static) {
                 span: Span::test_data(),
             },
         );
-        let _ = engine_state.merge_delta(
-            StateWorkingSet::new(&*engine_state).render(),
-            Some(&mut stack),
-            &cwd,
-        );
+
+        engine_state
+            .merge_env(&mut stack, &cwd)
+            .expect("Error merging environment");
 
         let (block, delta) = {
             let mut working_set = StateWorkingSet::new(&*engine_state);
@@ -99,7 +101,9 @@ pub fn test_examples(cmd: impl Command + 'static) {
             (output, working_set.render())
         };
 
-        let _ = engine_state.merge_delta(delta, None, &cwd);
+        engine_state
+            .merge_delta(delta)
+            .expect("Error merging delta");
 
         let mut stack = Stack::new();
 

crates/nu-command/src/experimental/view_source.rs

@@ -1,3 +1,4 @@
+use itertools::Itertools;
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
@@ -131,6 +132,15 @@ impl Command for ViewSource {
                             Vec::new(),
                         ))
                     }
+                } else if let Some(alias_id) = engine_state.find_alias(val.as_bytes(), &[]) {
+                    let contents = &mut engine_state.get_alias(alias_id).iter().map(|span| {
+                        String::from_utf8_lossy(engine_state.get_span_contents(span)).to_string()
+                    });
+                    Ok(Value::String {
+                        val: contents.join(" "),
+                        span: call.head,
+                    }
+                    .into_pipeline_data())
                 } else {
                     Err(ShellError::GenericError(
                         "Cannot view value".to_string(),
@@ -185,6 +195,14 @@ impl Command for ViewSource {
                     span: Span::test_data(),
                 }),
             },
+            Example {
+                description: "View the source of an alias",
+                example: r#"alias hello = echo hi; view-source hello"#,
+                result: Some(Value::String {
+                    val: "echo hi".to_string(),
+                    span: Span::test_data(),
+                }),
+            },
         ]
     }
 }

crates/nu-command/src/filesystem/cp.rs

@@ -1,11 +1,16 @@
+use std::collections::HashMap;
 use std::fs::read_link;
 use std::path::PathBuf;
 
+use itertools::Itertools;
 use nu_engine::env::current_dir;
 use nu_engine::CallExt;
+use nu_glob::GlobResult;
+use nu_path::dots::expand_ndots;
 use nu_path::{canonicalize_with, expand_path_with};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::span::span as merge_spans;
 use nu_protocol::{
     Category, Example, IntoInterruptiblePipelineData, PipelineData, ShellError, Signature, Span,
     Spanned, SyntaxShape, Value,
@@ -41,7 +46,12 @@ impl Command for Cp {
 
     fn signature(&self) -> Signature {
         Signature::build("cp")
-            .required("source", SyntaxShape::GlobPattern, "the place to copy from")
+            .rest(
+                "source(s)",
+                SyntaxShape::String,
+                "the place(s) to copy from",
+            )
+            // .required("source", SyntaxShape::GlobPattern, "the place to copy from")
             .required("destination", SyntaxShape::Filepath, "the place to copy to")
             .switch(
                 "recursive",
@@ -71,15 +81,16 @@ impl Command for Cp {
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let src: Spanned<String> = call.req(engine_state, stack, 0)?;
-        let dst: Spanned<String> = call.req(engine_state, stack, 1)?;
+        let mut src_vec: Vec<Spanned<String>> = call.rest(engine_state, stack, 0)?;
+        // read dst as final argument
+        let dst: Spanned<String> = src_vec.pop().expect("Final argument is destination");
+
         let recursive = call.has_flag("recursive");
         let verbose = call.has_flag("verbose");
         let interactive = call.has_flag("interactive");
 
         let current_dir_path = current_dir(engine_state, stack)?;
-        let source = current_dir_path.join(src.item.as_str());
-        let destination = current_dir_path.join(dst.item.as_str());
+        let destination = expand_ndots(current_dir_path.join(dst.item.as_str()));
 
         let path_last_char = destination.as_os_str().to_string_lossy().chars().last();
         let is_directory = path_last_char == Some('/') || path_last_char == Some('\\');
@@ -92,24 +103,54 @@ impl Command for Cp {
         let ctrlc = engine_state.ctrlc.clone();
         let span = call.head;
 
-        let sources: Vec<_> = match nu_glob::glob_with(&source.to_string_lossy(), GLOB_PARAMS) {
-            Ok(files) => files.collect(),
-            Err(e) => {
-                return Err(ShellError::GenericError(
-                    e.to_string(),
-                    "invalid pattern".to_string(),
-                    Some(src.span),
-                    None,
-                    Vec::new(),
-                ))
+        let mut sources: Vec<PathBuf> = vec![];
+        let mut path_to_span: HashMap<PathBuf, Span> = HashMap::new();
+
+        for src in &src_vec {
+            let source = current_dir_path.join(src.item.as_str());
+            let glob_results: Vec<GlobResult> =
+                match nu_glob::glob_with(&source.to_string_lossy(), GLOB_PARAMS) {
+                    Ok(files) => files.collect(),
+                    Err(e) => {
+                        return Err(ShellError::GenericError(
+                            e.to_string(),
+                            "invalid pattern".to_string(),
+                            Some(src.span),
+                            None,
+                            Vec::new(),
+                        ))
+                    }
+                };
+
+            let mut new_sources: Vec<PathBuf> = vec![];
+            for glob_result in glob_results {
+                match glob_result {
+                    Ok(path) => {
+                        path_to_span.insert(path.clone(), src.span);
+                        new_sources.push(path);
+                    }
+                    Err(e) => {
+                        return Err(ShellError::GenericError(
+                            e.to_string(),
+                            "glob iteration error".to_string(),
+                            Some(src.span),
+                            None,
+                            Vec::new(),
+                        ))
+                    }
+                }
             }
-        };
+
+            sources.append(&mut new_sources);
+        }
 
         if sources.is_empty() {
             return Err(ShellError::GenericError(
                 "No matches found".into(),
                 "no matches found".into(),
-                Some(src.span),
+                Some(merge_spans(
+                    &src_vec.into_iter().map(|src| src.span).collect_vec(),
+                )),
                 None,
                 Vec::new(),
             ));
@@ -125,21 +166,25 @@ impl Command for Cp {
             ));
         }
 
-        let any_source_is_dir = sources.iter().any(|f| matches!(f, Ok(f) if f.is_dir()));
+        let any_source_is_dir = sources.iter().find(|f| f.is_dir());
 
-        if any_source_is_dir && !recursive {
-            return Err(ShellError::GenericError(
-                "Directories must be copied using \"--recursive\"".into(),
-                "resolves to a directory (not copied)".into(),
-                Some(src.span),
-                None,
-                Vec::new(),
-            ));
+        if let Some(dir_source) = any_source_is_dir {
+            if !recursive {
+                return Err(ShellError::GenericError(
+                    "Directories must be copied using \"--recursive\"".into(),
+                    "resolves to a directory (not copied)".into(),
+                    Some(*path_to_span.get(dir_source).unwrap_or_else(|| {
+                        panic!("Key {:?} should exist", dir_source.as_os_str())
+                    })),
+                    None,
+                    Vec::new(),
+                ));
+            }
         }
 
         let mut result = Vec::new();
 
-        for entry in sources.into_iter().flatten() {
+        for entry in sources.into_iter() {
             let mut sources = FileStructure::new();
             sources.walk_decorate(&entry, engine_state, stack)?;
 
@@ -163,7 +208,8 @@ impl Command for Cp {
                         let res = if src == dst {
                             let message = format!(
                                 "src {:?} and dst {:?} are identical(not copied)",
-                                source, destination
+                                src.as_os_str(),
+                                destination
                             );
 
                             return Err(ShellError::GenericError(

crates/nu-command/src/filesystem/glob.rs

@@ -6,7 +6,7 @@ use nu_protocol::{
     Category, Example, IntoInterruptiblePipelineData, PipelineData, ShellError, Signature, Spanned,
     SyntaxShape, Value,
 };
-use wax::Glob as WaxGlob;
+use wax::{Glob as WaxGlob, WalkBehavior};
 
 #[derive(Clone)]
 pub struct Glob;
@@ -120,7 +120,13 @@ impl Command for Glob {
 
         #[allow(clippy::needless_collect)]
         let glob_results: Vec<Value> = glob
-            .walk(path, folder_depth)
+            .walk_with_behavior(
+                path,
+                WalkBehavior {
+                    depth: folder_depth,
+                    ..Default::default()
+                },
+            )
             .flatten()
             .map(|entry| Value::String {
                 val: entry.into_path().to_string_lossy().to_string(),

crates/nu-command/src/filesystem/ls.rs

@@ -1,15 +1,17 @@
 use crate::DirBuilder;
 use crate::DirInfo;
 use chrono::{DateTime, Local, LocalResult, TimeZone, Utc};
+use itertools::Itertools;
 use nu_engine::env::current_dir;
 use nu_engine::CallExt;
 use nu_glob::MatchOptions;
 use nu_path::expand_to_real_path;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::IntoPipelineData;
 use nu_protocol::{
-    Category, DataSource, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData,
-    PipelineMetadata, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
+    Category, DataSource, Example, IntoInterruptiblePipelineData, PipelineData, PipelineMetadata,
+    ShellError, Signature, Span, Spanned, SyntaxShape, Value,
 };
 use pathdiff::diff_paths;
 
@@ -38,7 +40,11 @@ impl Command for Ls {
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("ls")
             // Using a string instead of a glob pattern shape so it won't auto-expand
-            .optional("pattern", SyntaxShape::String, "the glob pattern to use")
+            .rest(
+                "pattern(s)",
+                SyntaxShape::String,
+                "the glob pattern(s) to use",
+            )
             .switch("all", "Show hidden files", Some('a'))
             .switch(
                 "long",
@@ -56,6 +62,11 @@ impl Command for Ls {
                 "Display the apparent directory size in place of the directory metadata size",
                 Some('d'),
             )
+            .switch(
+                "directory",
+                "List the specified directory itself instead of its contents",
+                Some('D'),
+            )
             .category(Category::FileSystem)
     }
 
@@ -71,22 +82,28 @@ impl Command for Ls {
         let short_names = call.has_flag("short-names");
         let full_paths = call.has_flag("full-paths");
         let du = call.has_flag("du");
+        let directory = call.has_flag("directory");
         let ctrl_c = engine_state.ctrlc.clone();
         let call_span = call.head;
         let cwd = current_dir(engine_state, stack)?;
 
-        let pattern_arg: Option<Spanned<String>> = call.opt(engine_state, stack, 0)?;
+        let mut shell_errors: Vec<ShellError> = vec![];
+        let pattern_args: Vec<Spanned<String>> = call.rest(engine_state, stack, 0)?;
+        let glob_results = if !pattern_args.is_empty() {
+            pattern_args
+                .into_iter()
+                .flat_map(|pattern_arg| {
+                    let mut path = expand_to_real_path(pattern_arg.clone().item);
+                    let p_tag = pattern_arg.span;
+                    let cwd = cwd.clone();
+                    let ctrl_c = ctrl_c.clone();
 
-        let (path, p_tag, absolute_path) = match pattern_arg {
-            Some(p) => {
-                let p_tag = p.span;
-                let mut p = expand_to_real_path(p.item);
-
-                let expanded = nu_path::expand_path_with(&p, &cwd);
-                if expanded.is_dir() {
-                    if permission_denied(&p) {
-                        #[cfg(unix)]
-                        let error_msg = format!(
+                    let expanded = nu_path::expand_path_with(&path, &cwd);
+                    // Avoid checking and pushing "*" to the path when directory (do not show contents) flag is true
+                    if !directory && expanded.is_dir() {
+                        if permission_denied(&path) {
+                            #[cfg(unix)]
+                            let error_msg = format!(
                             "The permissions of {:o} do not allow access for this user",
                             expanded
                                 .metadata()
@@ -97,131 +114,288 @@ impl Command for Ls {
                                 .mode()
                                 & 0o0777
                         );
-                        #[cfg(not(unix))]
-                        let error_msg = String::from("Permission denied");
-                        return Err(ShellError::GenericError(
-                            "Permission denied".to_string(),
-                            error_msg,
-                            Some(p_tag),
+                            #[cfg(not(unix))]
+                            let error_msg = String::from("Permission denied");
+                            shell_errors.push(ShellError::GenericError(
+                                "Permission denied".to_string(),
+                                error_msg,
+                                Some(p_tag),
+                                None,
+                                Vec::new(),
+                            ));
+                        }
+                        if is_empty_dir(&expanded) {
+                            return Vec::from([Value::nothing(call_span)]).into_iter();
+                        }
+                        path.push("*");
+                    }
+
+                    let absolute_path = path.is_absolute();
+
+                    let hidden_dir_specified = is_hidden_dir(&path);
+
+                    let glob_path = Spanned {
+                        item: path.display().to_string(),
+                        span: p_tag,
+                    };
+
+                    let glob_options = if all {
+                        None
+                    } else {
+                        let mut glob_options = MatchOptions::new();
+                        glob_options.recursive_match_hidden_dir = false;
+                        Some(glob_options)
+                    };
+                    let (prefix, paths) =
+                        nu_engine::glob_from(&glob_path, &cwd, call_span, glob_options)
+                            .expect("glob failure");
+
+                    let mut paths_peek = paths.peekable();
+                    if paths_peek.peek().is_none() {
+                        shell_errors.push(ShellError::GenericError(
+                            format!("No matches found for {}", &path.display().to_string()),
+                            "".to_string(),
                             None,
+                            Some("no matches found".to_string()),
                             Vec::new(),
                         ));
                     }
-                    if is_empty_dir(&expanded) {
-                        return Ok(Value::nothing(call_span).into_pipeline_data());
-                    }
-                    p.push("*");
-                }
-                let absolute_path = p.is_absolute();
-                (p, p_tag, absolute_path)
-            }
-            None => {
-                if is_empty_dir(current_dir(engine_state, stack)?) {
-                    return Ok(Value::nothing(call_span).into_pipeline_data());
-                } else {
-                    (PathBuf::from("./*"), call_span, false)
-                }
-            }
-        };
 
-        let hidden_dir_specified = is_hidden_dir(&path);
+                    let mut hidden_dirs = vec![];
 
-        let glob_path = Spanned {
-            item: path.display().to_string(),
-            span: p_tag,
-        };
+                    paths_peek
+                        .into_iter()
+                        .filter_map(move |x| match x {
+                            Ok(path) => {
+                                let metadata = match std::fs::symlink_metadata(&path) {
+                                    Ok(metadata) => Some(metadata),
+                                    Err(_) => None,
+                                };
+                                if path_contains_hidden_folder(&path, &hidden_dirs) {
+                                    return None;
+                                }
 
-        let glob_options = if all {
-            None
+                                if !all && !hidden_dir_specified && is_hidden_dir(&path) {
+                                    if path.is_dir() {
+                                        hidden_dirs.push(path);
+                                    }
+                                    return None;
+                                }
+
+                                let display_name = if short_names {
+                                    path.file_name().map(|os| os.to_string_lossy().to_string())
+                                } else if full_paths || absolute_path {
+                                    Some(path.to_string_lossy().to_string())
+                                } else if let Some(prefix) = &prefix {
+                                    if let Ok(remainder) = path.strip_prefix(&prefix) {
+                                        if directory {
+                                            // When the path is the same as the cwd, path_diff should be "."
+                                            let path_diff = if let Some(path_diff_not_dot) =
+                                                diff_paths(&path, &cwd)
+                                            {
+                                                let path_diff_not_dot =
+                                                    path_diff_not_dot.to_string_lossy();
+                                                if path_diff_not_dot.is_empty() {
+                                                    ".".to_string()
+                                                } else {
+                                                    path_diff_not_dot.to_string()
+                                                }
+                                            } else {
+                                                path.to_string_lossy().to_string()
+                                            };
+
+                                            Some(path_diff)
+                                        } else {
+                                            let new_prefix =
+                                                if let Some(pfx) = diff_paths(&prefix, &cwd) {
+                                                    pfx
+                                                } else {
+                                                    prefix.to_path_buf()
+                                                };
+
+                                            Some(
+                                                new_prefix
+                                                    .join(remainder)
+                                                    .to_string_lossy()
+                                                    .to_string(),
+                                            )
+                                        }
+                                    } else {
+                                        Some(path.to_string_lossy().to_string())
+                                    }
+                                } else {
+                                    Some(path.to_string_lossy().to_string())
+                                }
+                                .ok_or_else(|| {
+                                    ShellError::GenericError(
+                                        format!("Invalid file name: {:}", path.to_string_lossy()),
+                                        "invalid file name".into(),
+                                        Some(call_span),
+                                        None,
+                                        Vec::new(),
+                                    )
+                                });
+
+                                match display_name {
+                                    Ok(name) => {
+                                        let entry = dir_entry_dict(
+                                            &path,
+                                            &name,
+                                            metadata.as_ref(),
+                                            call_span,
+                                            long,
+                                            du,
+                                            ctrl_c.clone(),
+                                        );
+                                        match entry {
+                                            Ok(value) => Some(value),
+                                            Err(err) => Some(Value::Error { error: err }),
+                                        }
+                                    }
+                                    Err(err) => Some(Value::Error { error: err }),
+                                }
+                            }
+                            _ => Some(Value::Nothing { span: call_span }),
+                        })
+                        .collect_vec()
+                        .into_iter()
+                })
+                .collect_vec()
         } else {
-            let mut glob_options = MatchOptions::new();
-            glob_options.recursive_match_hidden_dir = false;
-            Some(glob_options)
-        };
-        let (prefix, paths) = nu_engine::glob_from(&glob_path, &cwd, call_span, glob_options)?;
+            let (path, p_tag, absolute_path) = if directory {
+                (PathBuf::from("."), call_span, false)
+            } else if is_empty_dir(current_dir(engine_state, stack)?) {
+                return Ok(Value::nothing(call_span).into_pipeline_data());
+            } else {
+                (PathBuf::from("./*"), call_span, false)
+            };
 
-        let mut paths_peek = paths.peekable();
-        if paths_peek.peek().is_none() {
-            return Err(ShellError::GenericError(
-                format!("No matches found for {}", &path.display().to_string()),
-                "".to_string(),
-                None,
-                Some("no matches found".to_string()),
-                Vec::new(),
-            ));
-        }
+            let hidden_dir_specified = is_hidden_dir(&path);
 
-        let mut hidden_dirs = vec![];
+            let glob_path = Spanned {
+                item: path.display().to_string(),
+                span: p_tag,
+            };
 
-        Ok(paths_peek
-            .into_iter()
-            .filter_map(move |x| match x {
-                Ok(path) => {
-                    let metadata = match std::fs::symlink_metadata(&path) {
-                        Ok(metadata) => Some(metadata),
-                        Err(_) => None,
-                    };
-                    if path_contains_hidden_folder(&path, &hidden_dirs) {
-                        return None;
-                    }
+            let glob_options = if all {
+                None
+            } else {
+                let mut glob_options = MatchOptions::new();
+                glob_options.recursive_match_hidden_dir = false;
+                Some(glob_options)
+            };
+            let (prefix, paths) = nu_engine::glob_from(&glob_path, &cwd, call_span, glob_options)?;
 
-                    if !all && !hidden_dir_specified && is_hidden_dir(&path) {
-                        if path.is_dir() {
-                            hidden_dirs.push(path);
+            let mut paths_peek = paths.peekable();
+            if paths_peek.peek().is_none() {
+                return Err(ShellError::GenericError(
+                    format!("No matches found for {}", &path.display().to_string()),
+                    "".to_string(),
+                    None,
+                    Some("no matches found".to_string()),
+                    Vec::new(),
+                ));
+            }
+
+            let mut hidden_dirs = vec![];
+
+            paths_peek
+                .into_iter()
+                .filter_map(move |x| match x {
+                    Ok(path) => {
+                        let metadata = match std::fs::symlink_metadata(&path) {
+                            Ok(metadata) => Some(metadata),
+                            Err(_) => None,
+                        };
+                        if path_contains_hidden_folder(&path, &hidden_dirs) {
+                            return None;
                         }
-                        return None;
-                    }
 
-                    let display_name = if short_names {
-                        path.file_name().map(|os| os.to_string_lossy().to_string())
-                    } else if full_paths || absolute_path {
-                        Some(path.to_string_lossy().to_string())
-                    } else if let Some(prefix) = &prefix {
-                        if let Ok(remainder) = path.strip_prefix(&prefix) {
-                            let new_prefix = if let Some(pfx) = diff_paths(&prefix, &cwd) {
-                                pfx
+                        if !all && !hidden_dir_specified && is_hidden_dir(&path) {
+                            if path.is_dir() {
+                                hidden_dirs.push(path);
+                            }
+                            return None;
+                        }
+
+                        let display_name = if short_names {
+                            path.file_name().map(|os| os.to_string_lossy().to_string())
+                        } else if full_paths || absolute_path {
+                            Some(path.to_string_lossy().to_string())
+                        } else if let Some(prefix) = &prefix {
+                            if let Ok(remainder) = path.strip_prefix(&prefix) {
+                                if directory {
+                                    // When the path is the same as the cwd, path_diff should be "."
+                                    let path_diff = if let Some(path_diff_not_dot) =
+                                        diff_paths(&path, &cwd)
+                                    {
+                                        let path_diff_not_dot = path_diff_not_dot.to_string_lossy();
+                                        if path_diff_not_dot.is_empty() {
+                                            ".".to_string()
+                                        } else {
+                                            path_diff_not_dot.to_string()
+                                        }
+                                    } else {
+                                        path.to_string_lossy().to_string()
+                                    };
+
+                                    Some(path_diff)
+                                } else {
+                                    let new_prefix = if let Some(pfx) = diff_paths(&prefix, &cwd) {
+                                        pfx
+                                    } else {
+                                        prefix.to_path_buf()
+                                    };
+
+                                    Some(new_prefix.join(remainder).to_string_lossy().to_string())
+                                }
                             } else {
-                                prefix.to_path_buf()
-                            };
-
-                            Some(new_prefix.join(remainder).to_string_lossy().to_string())
+                                Some(path.to_string_lossy().to_string())
+                            }
                         } else {
                             Some(path.to_string_lossy().to_string())
                         }
-                    } else {
-                        Some(path.to_string_lossy().to_string())
-                    }
-                    .ok_or_else(|| {
-                        ShellError::GenericError(
-                            format!("Invalid file name: {:}", path.to_string_lossy()),
-                            "invalid file name".into(),
-                            Some(call_span),
-                            None,
-                            Vec::new(),
-                        )
-                    });
+                        .ok_or_else(|| {
+                            ShellError::GenericError(
+                                format!("Invalid file name: {:}", path.to_string_lossy()),
+                                "invalid file name".into(),
+                                Some(call_span),
+                                None,
+                                Vec::new(),
+                            )
+                        });
 
-                    match display_name {
-                        Ok(name) => {
-                            let entry = dir_entry_dict(
-                                &path,
-                                &name,
-                                metadata.as_ref(),
-                                call_span,
-                                long,
-                                du,
-                                ctrl_c.clone(),
-                            );
-                            match entry {
-                                Ok(value) => Some(value),
-                                Err(err) => Some(Value::Error { error: err }),
+                        match display_name {
+                            Ok(name) => {
+                                let entry = dir_entry_dict(
+                                    &path,
+                                    &name,
+                                    metadata.as_ref(),
+                                    call_span,
+                                    long,
+                                    du,
+                                    ctrl_c.clone(),
+                                );
+                                match entry {
+                                    Ok(value) => Some(value),
+                                    Err(err) => Some(Value::Error { error: err }),
+                                }
                             }
+                            Err(err) => Some(Value::Error { error: err }),
                         }
-                        Err(err) => Some(Value::Error { error: err }),
                     }
-                }
-                _ => Some(Value::Nothing { span: call_span }),
-            })
+                    _ => Some(Value::Nothing { span: call_span }),
+                })
+                .collect_vec()
+        };
+
+        if !shell_errors.is_empty() {
+            return Err(shell_errors.pop().expect("Vec pop error"));
+        }
+
+        Ok(glob_results
+            .into_iter()
+            .filter(|result| !matches!(result, Value::Nothing { .. }))
             .into_pipeline_data_with_metadata(
                 PipelineMetadata {
                     data_source: DataSource::Ls,
@@ -252,6 +426,11 @@ impl Command for Ls {
                 example: "ls *.rs",
                 result: None,
             },
+            Example {
+                description: "List all rust files and all toml files",
+                example: "ls *.rs *.toml",
+                result: None,
+            },
             Example {
                 description: "List all files and directories whose name do not contain 'bar'",
                 example: "ls -s | where name !~ bar",
@@ -268,6 +447,12 @@ impl Command for Ls {
                 example: "ls -s ~ | where type == dir && modified < ((date now) - 7day)",
                 result: None,
             },
+            Example {
+                description: "List given paths, show directories themselves",
+                example:
+                    "['/path/to/directory' '/path/to/file'] | each { |it| ls -D $it } | flatten",
+                result: None,
+            },
         ]
     }
 }

crates/nu-command/src/filesystem/mv.rs

@@ -1,8 +1,11 @@
 use std::path::{Path, PathBuf};
 
 use super::util::try_interaction;
+use itertools::Itertools;
 use nu_engine::env::current_dir;
 use nu_engine::CallExt;
+use nu_glob::GlobResult;
+use nu_path::dots::expand_ndots;
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{Command, EngineState, Stack};
 use nu_protocol::{
@@ -36,11 +39,16 @@ impl Command for Mv {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("mv")
-            .required(
-                "source",
-                SyntaxShape::GlobPattern,
-                "the location to move files/directories from",
+            .rest(
+                "source(s)",
+                SyntaxShape::String,
+                "the location(s) to move files/directories from",
             )
+            // .required(
+            //     "source",
+            //     SyntaxShape::GlobPattern,
+            //     "the location to move files/directories from",
+            // )
             .required(
                 "destination",
                 SyntaxShape::Filepath,
@@ -64,114 +72,132 @@ impl Command for Mv {
         _input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
         // TODO: handle invalid directory or insufficient permissions when moving
-        let spanned_source: Spanned<String> = call.req(engine_state, stack, 0)?;
-        let spanned_destination: Spanned<String> = call.req(engine_state, stack, 1)?;
+        let mut spanned_sources: Vec<Spanned<String>> = call.rest(engine_state, stack, 0)?;
+        // read destination as final argument
+        let spanned_destination: Spanned<String> =
+            call.req(engine_state, stack, spanned_sources.len() - 1)?;
+        // don't read destination argument
+        spanned_sources.pop();
         let verbose = call.has_flag("verbose");
         let interactive = call.has_flag("interactive");
         // let force = call.has_flag("force");
 
         let ctrlc = engine_state.ctrlc.clone();
 
-        let path = current_dir(engine_state, stack)?;
-        let source = path.join(spanned_source.item.as_str());
-        let destination = path.join(spanned_destination.item.as_str());
-
-        let mut sources = nu_glob::glob_with(&source.to_string_lossy(), GLOB_PARAMS)
-            .map_or_else(|_| Vec::new(), Iterator::collect);
-
-        if sources.is_empty() {
-            return Err(ShellError::GenericError(
-                "Invalid file or pattern".into(),
-                "invalid file or pattern".into(),
-                Some(spanned_source.span),
-                None,
-                Vec::new(),
-            ));
-        }
-
-        // We have two possibilities.
-        //
-        // First, the destination exists.
-        //  - If a directory, move everything into that directory, otherwise
-        //  - if only a single source, overwrite the file, otherwise
-        //  - error.
-        //
-        // Second, the destination doesn't exist, so we can only rename a single source. Otherwise
-        // it's an error.
-
-        if (destination.exists() && !destination.is_dir() && sources.len() > 1)
-            || (!destination.exists() && sources.len() > 1)
-        {
-            return Err(ShellError::GenericError(
-                "Can only move multiple sources if destination is a directory".into(),
-                "destination must be a directory when multiple sources".into(),
-                Some(spanned_destination.span),
-                None,
-                Vec::new(),
-            ));
-        }
-
-        let some_if_source_is_destination = sources
-            .iter()
-            .find(|f| matches!(f, Ok(f) if destination.starts_with(f)));
-        if destination.exists() && destination.is_dir() && sources.len() == 1 {
-            if let Some(Ok(filename)) = some_if_source_is_destination {
-                return Err(ShellError::GenericError(
-                    format!(
-                        "Not possible to move {:?} to itself",
-                        filename.file_name().expect("Invalid file name")
-                    ),
-                    "cannot move to itself".into(),
-                    Some(spanned_destination.span),
-                    None,
-                    Vec::new(),
-                ));
-            }
-        }
-
-        if let Some(Ok(_filename)) = some_if_source_is_destination {
-            sources = sources
-                .into_iter()
-                .filter(|f| matches!(f, Ok(f) if !destination.starts_with(f)))
-                .collect();
-        }
+        let path = current_dir(engine_state, stack).expect("Failed current_dir");
 
         let span = call.head;
-        Ok(sources
+
+        Ok(spanned_sources
             .into_iter()
-            .flatten()
-            .filter_map(move |entry| {
-                let result = move_file(
-                    Spanned {
-                        item: entry.clone(),
-                        span: spanned_source.span,
-                    },
-                    Spanned {
-                        item: destination.clone(),
-                        span: spanned_destination.span,
-                    },
-                    interactive,
-                );
-                if let Err(error) = result {
-                    Some(Value::Error { error })
-                } else if verbose {
-                    let val = if result.expect("Error value when unwrapping mv result") {
-                        format!(
-                            "moved {:} to {:}",
-                            entry.to_string_lossy(),
-                            destination.to_string_lossy()
-                        )
-                    } else {
-                        format!(
-                            "{:} not moved to {:}",
-                            entry.to_string_lossy(),
-                            destination.to_string_lossy()
-                        )
-                    };
-                    Some(Value::String { val, span })
-                } else {
-                    None
+            .flat_map(move |spanned_source| {
+                let path = path.clone();
+                let source = path.join(spanned_source.item.as_str());
+                let destination = expand_ndots(path.join(spanned_destination.item.as_str()));
+
+                let mut sources: Vec<GlobResult> =
+                    nu_glob::glob_with(&source.to_string_lossy(), GLOB_PARAMS)
+                        .map_or_else(|_| Vec::new(), Iterator::collect);
+
+                if sources.is_empty() {
+                    let err = ShellError::GenericError(
+                        "Invalid file or pattern".into(),
+                        "invalid file or pattern".into(),
+                        Some(spanned_source.span),
+                        None,
+                        Vec::new(),
+                    );
+                    return Vec::from([Value::Error { error: err }]).into_iter();
                 }
+
+                // We have two possibilities.
+                //
+                // First, the destination exists.
+                //  - If a directory, move everything into that directory, otherwise
+                //  - if only a single source, overwrite the file, otherwise
+                //  - error.
+                //
+                // Second, the destination doesn't exist, so we can only rename a single source. Otherwise
+                // it's an error.
+
+                if (destination.exists() && !destination.is_dir() && sources.len() > 1)
+                    || (!destination.exists() && sources.len() > 1)
+                {
+                    let err = ShellError::GenericError(
+                        "Can only move multiple sources if destination is a directory".into(),
+                        "destination must be a directory when multiple sources".into(),
+                        Some(spanned_destination.span),
+                        None,
+                        Vec::new(),
+                    );
+                    return Vec::from([Value::Error { error: err }]).into_iter();
+                }
+
+                let some_if_source_is_destination = sources
+                    .iter()
+                    .find(|f| matches!(f, Ok(f) if destination.starts_with(f)));
+                if destination.exists() && destination.is_dir() && sources.len() == 1 {
+                    if let Some(Ok(filename)) = some_if_source_is_destination {
+                        let err = ShellError::GenericError(
+                            format!(
+                                "Not possible to move {:?} to itself",
+                                filename.file_name().expect("Invalid file name")
+                            ),
+                            "cannot move to itself".into(),
+                            Some(spanned_destination.span),
+                            None,
+                            Vec::new(),
+                        );
+                        return Vec::from([Value::Error { error: err }]).into_iter();
+                    }
+                }
+
+                if let Some(Ok(_filename)) = some_if_source_is_destination {
+                    sources = sources
+                        .into_iter()
+                        .filter(|f| matches!(f, Ok(f) if !destination.starts_with(f)))
+                        .collect();
+                }
+
+                sources
+                    .into_iter()
+                    .flatten()
+                    .filter_map(move |entry| {
+                        let entry = expand_ndots(entry);
+                        let result = move_file(
+                            Spanned {
+                                item: entry.clone(),
+                                span: spanned_source.span,
+                            },
+                            Spanned {
+                                item: destination.clone(),
+                                span: spanned_destination.span,
+                            },
+                            interactive,
+                        );
+                        if let Err(error) = result {
+                            Some(Value::Error { error })
+                        } else if verbose {
+                            let val = if result.expect("Error value when unwrapping mv result") {
+                                format!(
+                                    "moved {:} to {:}",
+                                    entry.to_string_lossy(),
+                                    destination.to_string_lossy()
+                                )
+                            } else {
+                                format!(
+                                    "{:} not moved to {:}",
+                                    entry.to_string_lossy(),
+                                    destination.to_string_lossy()
+                                )
+                            };
+                            Some(Value::String { val, span })
+                        } else {
+                            None
+                        }
+                    })
+                    .collect_vec()
+                    .into_iter()
             })
             .into_pipeline_data(ctrlc))
     }

crates/nu-command/src/filesystem/open.rs

@@ -88,14 +88,14 @@ impl Command for Open {
 
         if permission_denied(&path) {
             #[cfg(unix)]
-            let error_msg = format!(
-                "The permissions of {:o} do not allow access for this user",
-                path.metadata()
-                    .expect("this shouldn't be called since we already know there is a dir")
-                    .permissions()
-                    .mode()
-                    & 0o0777
-            );
+            let error_msg = match path.metadata() {
+                Ok(md) => format!(
+                    "The permissions of {:o} does not allow access for this user",
+                    md.permissions().mode() & 0o0777
+                ),
+                Err(e) => e.to_string(),
+            };
+
             #[cfg(not(unix))]
             let error_msg = String::from("Permission denied");
             Err(ShellError::GenericError(

crates/nu-command/src/filters/all.rs

@@ -66,27 +66,31 @@ impl Command for All {
         let ctrlc = engine_state.ctrlc.clone();
         let engine_state = engine_state.clone();
 
-        Ok(Value::Bool {
-            val: input.into_interruptible_iter(ctrlc).all(move |value| {
-                if let Some(var_id) = var_id {
-                    stack.add_var(var_id, value);
-                }
+        for value in input.into_interruptible_iter(ctrlc) {
+            if let Some(var_id) = var_id {
+                stack.add_var(var_id, value);
+            }
 
-                eval_block(
-                    &engine_state,
-                    &mut stack,
-                    block,
-                    PipelineData::new(span),
-                    call.redirect_stdout,
-                    call.redirect_stderr,
-                )
-                .map_or(false, |pipeline_data| {
-                    pipeline_data.into_value(span).is_true()
-                })
-            }),
-            span,
+            let eval = eval_block(
+                &engine_state,
+                &mut stack,
+                block,
+                PipelineData::new(span),
+                call.redirect_stdout,
+                call.redirect_stderr,
+            );
+            match eval {
+                Err(e) => {
+                    return Err(e);
+                }
+                Ok(pipeline_data) => {
+                    if !pipeline_data.into_value(span).is_true() {
+                        return Ok(Value::Bool { val: false, span }.into_pipeline_data());
+                    }
+                }
+            }
         }
-        .into_pipeline_data())
+        Ok(Value::Bool { val: true, span }.into_pipeline_data())
     }
 }
 

crates/nu-command/src/filters/any.rs

@@ -65,27 +65,31 @@ impl Command for Any {
         let ctrlc = engine_state.ctrlc.clone();
         let engine_state = engine_state.clone();
 
-        Ok(Value::Bool {
-            val: input.into_interruptible_iter(ctrlc).any(move |value| {
-                if let Some(var_id) = var_id {
-                    stack.add_var(var_id, value);
-                }
+        for value in input.into_interruptible_iter(ctrlc) {
+            if let Some(var_id) = var_id {
+                stack.add_var(var_id, value);
+            }
 
-                eval_block(
-                    &engine_state,
-                    &mut stack,
-                    block,
-                    PipelineData::new(span),
-                    call.redirect_stdout,
-                    call.redirect_stderr,
-                )
-                .map_or(false, |pipeline_data| {
-                    pipeline_data.into_value(span).is_true()
-                })
-            }),
-            span,
+            let eval = eval_block(
+                &engine_state,
+                &mut stack,
+                block,
+                PipelineData::new(span),
+                call.redirect_stdout,
+                call.redirect_stderr,
+            );
+            match eval {
+                Err(e) => {
+                    return Err(e);
+                }
+                Ok(pipeline_data) => {
+                    if pipeline_data.into_value(span).is_true() {
+                        return Ok(Value::Bool { val: true, span }.into_pipeline_data());
+                    }
+                }
+            }
         }
-        .into_pipeline_data())
+        Ok(Value::Bool { val: false, span }.into_pipeline_data())
     }
 }
 

crates/nu-command/src/filters/find.rs

@@ -1,10 +1,15 @@
-use nu_engine::{eval_block, CallExt};
+use crate::help::highlight_search_string;
+use lscolors::Style as LsColors_Style;
+use nu_ansi_term::{Color::Default, Style};
+use nu_color_config::get_color_config;
+use nu_engine::{env_to_string, eval_block, CallExt};
 use nu_protocol::{
     ast::Call,
     engine::{CaptureBlock, Command, EngineState, Stack},
-    Category, Example, IntoInterruptiblePipelineData, PipelineData, ShellError, Signature, Span,
-    SyntaxShape, Value,
+    Category, Example, IntoInterruptiblePipelineData, ListStream, PipelineData, ShellError,
+    Signature, Span, SyntaxShape, Value,
 };
+use nu_utils::get_ls_colors;
 use regex::Regex;
 
 #[derive(Clone)]
@@ -149,7 +154,7 @@ impl Command for Find {
                 find_with_predicate(predicate, engine_state, stack, call, input)
             }
             (Some(regex), None) => find_with_regex(regex, engine_state, stack, call, input),
-            (None, None) => find_with_rest(engine_state, stack, call, input),
+            (None, None) => find_with_rest_and_highlight(engine_state, stack, call, input),
             (Some(_), Some(_)) => Err(ShellError::IncompatibleParametersSingle(
                 "expected either predicate or regex flag, not both".to_owned(),
                 call.head,
@@ -265,7 +270,7 @@ fn find_with_predicate(
     )
 }
 
-fn find_with_rest(
+fn find_with_rest_and_highlight(
     engine_state: &EngineState,
     stack: &mut Stack,
     call: &Call,
@@ -273,11 +278,10 @@ fn find_with_rest(
 ) -> Result<PipelineData, ShellError> {
     let span = call.head;
     let ctrlc = engine_state.ctrlc.clone();
-    let metadata = input.metadata();
     let engine_state = engine_state.clone();
     let config = engine_state.get_config().clone();
+    let filter_config = engine_state.get_config().clone();
     let invert = call.has_flag("invert");
-
     let terms = call.rest::<Value>(&engine_state, stack, 0)?;
     let lower_terms = terms
         .iter()
@@ -290,56 +294,236 @@ fn find_with_rest(
         })
         .collect::<Vec<Value>>();
 
-    let pipe = input.filter(
-        move |value| {
-            let lower_value = if let Ok(span) = value.span() {
-                Value::string(value.into_string("", &config).to_lowercase(), span)
-            } else {
-                value.clone()
-            };
+    let color_hm = get_color_config(&config);
+    let default_style = Style::new().fg(Default).on(Default);
+    let string_style = match color_hm.get("string") {
+        Some(style) => *style,
+        None => default_style,
+    };
+    let ls_colors_env_str = match stack.get_env_var(&engine_state, "LS_COLORS") {
+        Some(v) => Some(env_to_string("LS_COLORS", &v, &engine_state, stack)?),
+        None => None,
+    };
+    let ls_colors = get_ls_colors(ls_colors_env_str);
 
-            lower_terms.iter().any(|term| match value {
-                Value::Bool { .. }
-                | Value::Int { .. }
-                | Value::Filesize { .. }
-                | Value::Duration { .. }
-                | Value::Date { .. }
-                | Value::Range { .. }
-                | Value::Float { .. }
-                | Value::Block { .. }
-                | Value::Nothing { .. }
-                | Value::Error { .. } => lower_value
-                    .eq(span, term, span)
-                    .map_or(false, |value| value.is_true()),
-                Value::String { .. }
-                | Value::List { .. }
-                | Value::CellPath { .. }
-                | Value::CustomValue { .. } => term
-                    .r#in(span, &lower_value, span)
-                    .map_or(false, |value| value.is_true()),
-                Value::Record { vals, .. } => vals.iter().any(|val| {
-                    if let Ok(span) = val.span() {
-                        let lower_val = Value::string(
-                            val.into_string("", &config).to_lowercase(),
-                            Span::test_data(),
-                        );
+    match input {
+        PipelineData::Value(_, _) => input.filter(
+            move |value| {
+                let lower_value = if let Ok(span) = value.span() {
+                    Value::string(value.into_string("", &config).to_lowercase(), span)
+                } else {
+                    value.clone()
+                };
 
-                        term.r#in(span, &lower_val, span)
-                            .map_or(false, |value| value.is_true())
-                    } else {
-                        term.r#in(span, val, span)
-                            .map_or(false, |value| value.is_true())
+                lower_terms.iter().any(|term| match value {
+                    Value::Bool { .. }
+                    | Value::Int { .. }
+                    | Value::Filesize { .. }
+                    | Value::Duration { .. }
+                    | Value::Date { .. }
+                    | Value::Range { .. }
+                    | Value::Float { .. }
+                    | Value::Block { .. }
+                    | Value::Nothing { .. }
+                    | Value::Error { .. } => lower_value
+                        .eq(span, term, span)
+                        .map_or(false, |val| val.is_true()),
+                    Value::String { .. }
+                    | Value::List { .. }
+                    | Value::CellPath { .. }
+                    | Value::CustomValue { .. } => term
+                        .r#in(span, &lower_value, span)
+                        .map_or(false, |val| val.is_true()),
+                    Value::Record { vals, .. } => vals.iter().any(|val| {
+                        if let Ok(span) = val.span() {
+                            let lower_val = Value::string(
+                                val.into_string("", &config).to_lowercase(),
+                                Span::test_data(),
+                            );
+
+                            term.r#in(span, &lower_val, span)
+                                .map_or(false, |aval| aval.is_true())
+                        } else {
+                            term.r#in(span, val, span)
+                                .map_or(false, |aval| aval.is_true())
+                        }
+                    }),
+                    Value::Binary { .. } => false,
+                }) != invert
+            },
+            ctrlc,
+        ),
+        PipelineData::ListStream(stream, meta) => {
+            Ok(ListStream::from_stream(
+                stream
+                    .map(move |mut x| match &mut x {
+                        Value::Record { cols, vals, span } => {
+                            let mut output = vec![];
+                            for val in vals {
+                                let val_str = val.into_string("", &config);
+                                let lower_val = val.into_string("", &config).to_lowercase();
+                                let mut term_added_to_output = false;
+                                for term in terms.clone() {
+                                    let term_str = term.into_string("", &config);
+                                    let lower_term = term.into_string("", &config).to_lowercase();
+                                    if lower_val.contains(&lower_term) {
+                                        if config.use_ls_colors {
+                                            // Get the original LS_COLORS color
+                                            let style = ls_colors.style_for_path(val_str.clone());
+                                            let ansi_style = style
+                                                .map(LsColors_Style::to_crossterm_style)
+                                                .unwrap_or_default();
+
+                                            let ls_colored_val =
+                                                ansi_style.apply(&val_str).to_string();
+                                            let hi = match highlight_search_string(
+                                                &ls_colored_val,
+                                                &term_str,
+                                                &string_style,
+                                            ) {
+                                                Ok(hi) => hi,
+                                                Err(_) => string_style
+                                                    .paint(term_str.to_string())
+                                                    .to_string(),
+                                            };
+                                            output.push(Value::String {
+                                                val: hi,
+                                                span: *span,
+                                            });
+                                            term_added_to_output = true;
+                                        } else {
+                                            // No LS_COLORS support, so just use the original value
+                                            let hi = match highlight_search_string(
+                                                &val_str,
+                                                &term_str,
+                                                &string_style,
+                                            ) {
+                                                Ok(hi) => hi,
+                                                Err(_) => string_style
+                                                    .paint(term_str.to_string())
+                                                    .to_string(),
+                                            };
+                                            output.push(Value::String {
+                                                val: hi,
+                                                span: *span,
+                                            });
+                                        }
+                                    }
+                                }
+                                if !term_added_to_output {
+                                    output.push(val.clone());
+                                }
+                            }
+                            Value::Record {
+                                cols: cols.to_vec(),
+                                vals: output,
+                                span: *span,
+                            }
+                        }
+                        _ => x,
+                    })
+                    .filter(move |value| {
+                        let lower_value = if let Ok(span) = value.span() {
+                            Value::string(
+                                value.into_string("", &filter_config).to_lowercase(),
+                                span,
+                            )
+                        } else {
+                            value.clone()
+                        };
+
+                        lower_terms.iter().any(|term| match value {
+                            Value::Bool { .. }
+                            | Value::Int { .. }
+                            | Value::Filesize { .. }
+                            | Value::Duration { .. }
+                            | Value::Date { .. }
+                            | Value::Range { .. }
+                            | Value::Float { .. }
+                            | Value::Block { .. }
+                            | Value::Nothing { .. }
+                            | Value::Error { .. } => lower_value
+                                .eq(span, term, span)
+                                .map_or(false, |value| value.is_true()),
+                            Value::String { .. }
+                            | Value::List { .. }
+                            | Value::CellPath { .. }
+                            | Value::CustomValue { .. } => term
+                                .r#in(span, &lower_value, span)
+                                .map_or(false, |value| value.is_true()),
+                            Value::Record { vals, .. } => vals.iter().any(|val| {
+                                if let Ok(span) = val.span() {
+                                    let lower_val = Value::string(
+                                        val.into_string("", &filter_config).to_lowercase(),
+                                        Span::test_data(),
+                                    );
+
+                                    term.r#in(span, &lower_val, span)
+                                        .map_or(false, |value| value.is_true())
+                                } else {
+                                    term.r#in(span, val, span)
+                                        .map_or(false, |value| value.is_true())
+                                }
+                            }),
+                            Value::Binary { .. } => false,
+                        }) != invert
+                    }),
+                ctrlc.clone(),
+            )
+            .into_pipeline_data(ctrlc)
+            .set_metadata(meta))
+        }
+        PipelineData::ExternalStream { stdout: None, .. } => Ok(PipelineData::new(span)),
+        PipelineData::ExternalStream {
+            stdout: Some(stream),
+            ..
+        } => {
+            let mut output: Vec<Value> = vec![];
+            for filter_val in stream {
+                match filter_val {
+                    Ok(value) => match value {
+                        Value::String { val, span } => {
+                            let split_char = if val.contains("\r\n") { "\r\n" } else { "\n" };
+
+                            for line in val.split(split_char) {
+                                for term in lower_terms.iter() {
+                                    let term_str = term.into_string("", &filter_config);
+                                    let lower_val = line.to_lowercase();
+                                    if lower_val
+                                        .contains(&term.into_string("", &config).to_lowercase())
+                                    {
+                                        output.push(Value::String {
+                                            val: highlight_search_string(
+                                                line,
+                                                &term_str,
+                                                &string_style,
+                                            )?,
+                                            span,
+                                        })
+                                    }
+                                }
+                            }
+                        }
+                        _ => {
+                            return Err(ShellError::UnsupportedInput(
+                                format!(
+                                    "Unsupport value type '{}' from raw stream",
+                                    value.get_type()
+                                ),
+                                span,
+                            ))
+                        }
+                    },
+                    _ => {
+                        return Err(ShellError::UnsupportedInput(
+                            "Unsupport type from raw stream".to_string(),
+                            span,
+                        ))
                     }
-                }),
-                Value::Binary { .. } => false,
-            }) != invert
-        },
-        ctrlc,
-    )?;
-
-    match metadata {
-        Some(m) => Ok(pipe.into_pipeline_data_with_metadata(m, engine_state.ctrlc.clone())),
-        None => Ok(pipe),
+                };
+            }
+            Ok(output.into_pipeline_data(ctrlc))
+        }
     }
 }
 

crates/nu-command/src/filters/length.rs

@@ -25,7 +25,7 @@ impl Command for Length {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["count", "len", "size"]
+        vec!["count", "len", "size", "wc"]
     }
 
     fn run(

crates/nu-command/src/filters/reverse.rs

@@ -21,6 +21,10 @@ impl Command for Reverse {
         "Reverses the table."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["convert, inverse, flip"]
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             example: "[0,1,2,3] | reverse",

crates/nu-command/src/filters/select.rs

@@ -29,6 +29,10 @@ impl Command for Select {
         "Down-select table to only these columns."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["pick", "choose", "get"]
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,

crates/nu-command/src/filters/skip/skip_.rs

@@ -26,6 +26,10 @@ impl Command for Skip {
         "Skip the first n elements of the input."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["ignore", "remove"]
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {

crates/nu-command/src/filters/skip/skip_until.rs

@@ -28,6 +28,10 @@ impl Command for SkipUntil {
         "Skip elements of the input until a predicate is true."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["ignore"]
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Skip until the element is positive",

crates/nu-command/src/filters/skip/skip_while.rs

@@ -28,6 +28,10 @@ impl Command for SkipWhile {
         "Skip elements of the input while a predicate is true."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["ignore"]
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Skip while the element is negative",

crates/nu-command/src/filters/where_.rs

@@ -2,7 +2,8 @@ use nu_engine::{eval_block, CallExt};
 use nu_protocol::ast::Call;
 use nu_protocol::engine::{CaptureBlock, Command, EngineState, Stack};
 use nu_protocol::{
-    Category, Example, IntoInterruptiblePipelineData, PipelineData, Signature, SyntaxShape, Value,
+    Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData, ShellError,
+    Signature, Span, SyntaxShape, Value,
 };
 
 #[derive(Clone)]
@@ -19,7 +20,13 @@ impl Command for Where {
 
     fn signature(&self) -> nu_protocol::Signature {
         Signature::build("where")
-            .required("cond", SyntaxShape::RowCondition, "condition")
+            .optional("cond", SyntaxShape::RowCondition, "condition")
+            .named(
+                "block",
+                SyntaxShape::Block(Some(vec![SyntaxShape::Any])),
+                "use where with a block or variable instead",
+                Some('b'),
+            )
             .category(Category::Filters)
     }
 
@@ -34,51 +41,172 @@ impl Command for Where {
         call: &Call,
         input: PipelineData,
     ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
-        let span = call.head;
+        if let Ok(Some(capture_block)) = call.get_flag::<CaptureBlock>(engine_state, stack, "block")
+        {
+            let metadata = input.metadata();
+            let ctrlc = engine_state.ctrlc.clone();
+            let engine_state = engine_state.clone();
+            let block = engine_state.get_block(capture_block.block_id).clone();
+            let mut stack = stack.captures_to_stack(&capture_block.captures);
+            let orig_env_vars = stack.env_vars.clone();
+            let orig_env_hidden = stack.env_hidden.clone();
+            let span = call.head;
+            let redirect_stdout = call.redirect_stdout;
+            let redirect_stderr = call.redirect_stderr;
 
-        let metadata = input.metadata();
+            match input {
+                PipelineData::Value(Value::Range { .. }, ..)
+                | PipelineData::Value(Value::List { .. }, ..)
+                | PipelineData::ListStream { .. } => Ok(input
+                    .into_iter()
+                    .filter_map(move |x| {
+                        stack.with_env(&orig_env_vars, &orig_env_hidden);
 
-        let block: CaptureBlock = call.req(engine_state, stack, 0)?;
-        let mut stack = stack.captures_to_stack(&block.captures);
-        let block = engine_state.get_block(block.block_id).clone();
+                        if let Some(var) = block.signature.get_positional(0) {
+                            if let Some(var_id) = &var.var_id {
+                                stack.add_var(*var_id, x.clone());
+                            }
+                        }
 
-        let ctrlc = engine_state.ctrlc.clone();
-        let engine_state = engine_state.clone();
-
-        let redirect_stdout = call.redirect_stdout;
-        let redirect_stderr = call.redirect_stderr;
-
-        Ok(input
-            .into_iter()
-            .filter_map(move |value| {
-                if let Some(var) = block.signature.get_positional(0) {
-                    if let Some(var_id) = &var.var_id {
-                        stack.add_var(*var_id, value.clone());
-                    }
+                        match eval_block(
+                            &engine_state,
+                            &mut stack,
+                            &block,
+                            x.clone().into_pipeline_data(),
+                            redirect_stdout,
+                            redirect_stderr,
+                        ) {
+                            Ok(v) => {
+                                if v.into_value(span).is_true() {
+                                    Some(x)
+                                } else {
+                                    None
+                                }
+                            }
+                            Err(error) => Some(Value::Error { error }),
+                        }
+                    })
+                    .into_pipeline_data(ctrlc)),
+                PipelineData::ExternalStream { stdout: None, .. } => {
+                    Ok(PipelineData::new(call.head))
                 }
-                let result = eval_block(
-                    &engine_state,
-                    &mut stack,
-                    &block,
-                    PipelineData::new(span),
-                    redirect_stdout,
-                    redirect_stderr,
-                );
+                PipelineData::ExternalStream {
+                    stdout: Some(stream),
+                    ..
+                } => Ok(stream
+                    .into_iter()
+                    .filter_map(move |x| {
+                        stack.with_env(&orig_env_vars, &orig_env_hidden);
 
-                match result {
-                    Ok(result) => {
-                        let result = result.into_value(span);
-                        if result.is_true() {
-                            Some(value)
-                        } else {
-                            None
+                        let x = match x {
+                            Ok(x) => x,
+                            Err(err) => return Some(Value::Error { error: err }),
+                        };
+
+                        if let Some(var) = block.signature.get_positional(0) {
+                            if let Some(var_id) = &var.var_id {
+                                stack.add_var(*var_id, x.clone());
+                            }
+                        }
+
+                        match eval_block(
+                            &engine_state,
+                            &mut stack,
+                            &block,
+                            x.clone().into_pipeline_data(),
+                            redirect_stdout,
+                            redirect_stderr,
+                        ) {
+                            Ok(v) => {
+                                if v.into_value(span).is_true() {
+                                    Some(x)
+                                } else {
+                                    None
+                                }
+                            }
+                            Err(error) => Some(Value::Error { error }),
+                        }
+                    })
+                    .into_pipeline_data(ctrlc)),
+                PipelineData::Value(x, ..) => {
+                    if let Some(var) = block.signature.get_positional(0) {
+                        if let Some(var_id) = &var.var_id {
+                            stack.add_var(*var_id, x.clone());
                         }
                     }
-                    Err(err) => Some(Value::Error { error: err }),
+                    Ok(match eval_block(
+                        &engine_state,
+                        &mut stack,
+                        &block,
+                        x.clone().into_pipeline_data(),
+                        redirect_stdout,
+                        redirect_stderr,
+                    ) {
+                        Ok(v) => {
+                            if v.into_value(span).is_true() {
+                                Some(x)
+                            } else {
+                                None
+                            }
+                        }
+                        Err(error) => Some(Value::Error { error }),
+                    }
+                    .into_pipeline_data(ctrlc))
                 }
-            })
-            .into_pipeline_data(ctrlc))
-        .map(|x| x.set_metadata(metadata))
+            }
+            .map(|x| x.set_metadata(metadata))
+        } else {
+            let capture_block: Option<CaptureBlock> = call.opt(engine_state, stack, 0)?;
+            if let Some(block) = capture_block {
+                let span = call.head;
+
+                let metadata = input.metadata();
+                let mut stack = stack.captures_to_stack(&block.captures);
+                let block = engine_state.get_block(block.block_id).clone();
+
+                let ctrlc = engine_state.ctrlc.clone();
+                let engine_state = engine_state.clone();
+
+                let redirect_stdout = call.redirect_stdout;
+                let redirect_stderr = call.redirect_stderr;
+                Ok(input
+                    .into_iter()
+                    .filter_map(move |value| {
+                        if let Some(var) = block.signature.get_positional(0) {
+                            if let Some(var_id) = &var.var_id {
+                                stack.add_var(*var_id, value.clone());
+                            }
+                        }
+                        let result = eval_block(
+                            &engine_state,
+                            &mut stack,
+                            &block,
+                            PipelineData::new(span),
+                            redirect_stdout,
+                            redirect_stderr,
+                        );
+
+                        match result {
+                            Ok(result) => {
+                                let result = result.into_value(span);
+                                if result.is_true() {
+                                    Some(value)
+                                } else {
+                                    None
+                                }
+                            }
+                            Err(err) => Some(Value::Error { error: err }),
+                        }
+                    })
+                    .into_pipeline_data(ctrlc))
+                .map(|x| x.set_metadata(metadata))
+            } else {
+                Err(ShellError::MissingParameter(
+                    "condition".to_string(),
+                    call.head,
+                ))
+            }
+        }
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -103,6 +231,23 @@ impl Command for Where {
                 example: "ls | where modified >= (date now) - 2wk",
                 result: None,
             },
+            Example {
+                description: "Get all numbers above 3 with an existing block condition",
+                example: "let a = {$in > 3}; [1, 2, 5, 6] | where -b $a",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::Int {
+                            val: 5,
+                            span: Span::test_data(),
+                        },
+                        Value::Int {
+                            val: 6,
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
         ]
     }
 }

crates/nu-command/src/formats/from/nuon.rs

@@ -442,6 +442,14 @@ fn convert_to_value(
                     val: size * 1000 * 1000 * 1000 * 1000 * 1000,
                     span,
                 }),
+                Unit::Exabyte => Ok(Value::Filesize {
+                    val: size * 1000 * 1000 * 1000 * 1000 * 1000 * 1000,
+                    span,
+                }),
+                Unit::Zettabyte => Ok(Value::Filesize {
+                    val: size * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000,
+                    span,
+                }),
 
                 Unit::Kibibyte => Ok(Value::Filesize {
                     val: size * 1024,
@@ -463,6 +471,14 @@ fn convert_to_value(
                     val: size * 1024 * 1024 * 1024 * 1024 * 1024,
                     span,
                 }),
+                Unit::Exbibyte => Ok(Value::Filesize {
+                    val: size * 1024 * 1024 * 1024 * 1024 * 1024 * 1024,
+                    span,
+                }),
+                Unit::Zebibyte => Ok(Value::Filesize {
+                    val: size * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024,
+                    span,
+                }),
 
                 Unit::Nanosecond => Ok(Value::Duration { val: size, span }),
                 Unit::Microsecond => Ok(Value::Duration {
@@ -489,8 +505,8 @@ fn convert_to_value(
                     Some(val) => Ok(Value::Duration { val, span }),
                     None => Err(ShellError::OutsideSpannedLabeledError(
                         original_text.to_string(),
-                        "duration too large".into(),
-                        "duration too large".into(),
+                        "day duration too large".into(),
+                        "day duration too large".into(),
                         expr.span,
                     )),
                 },
@@ -499,11 +515,40 @@ fn convert_to_value(
                     Some(val) => Ok(Value::Duration { val, span }),
                     None => Err(ShellError::OutsideSpannedLabeledError(
                         original_text.to_string(),
-                        "duration too large".into(),
-                        "duration too large".into(),
+                        "week duration too large".into(),
+                        "week duration too large".into(),
                         expr.span,
                     )),
                 },
+                Unit::Month => match size.checked_mul(1000 * 1000 * 1000 * 60 * 60 * 24 * 30) {
+                    Some(val) => Ok(Value::Duration { val, span }),
+                    None => Err(ShellError::OutsideSpannedLabeledError(
+                        original_text.to_string(),
+                        "month duration too large".into(),
+                        "month duration too large".into(),
+                        expr.span,
+                    )),
+                },
+                Unit::Year => match size.checked_mul(1000 * 1000 * 1000 * 60 * 60 * 24 * 365) {
+                    Some(val) => Ok(Value::Duration { val, span }),
+                    None => Err(ShellError::OutsideSpannedLabeledError(
+                        original_text.to_string(),
+                        "year duration too large".into(),
+                        "year duration too large".into(),
+                        expr.span,
+                    )),
+                },
+                Unit::Decade => {
+                    match size.checked_mul(1000 * 1000 * 1000 * 60 * 60 * 24 * 365 * 10) {
+                        Some(val) => Ok(Value::Duration { val, span }),
+                        None => Err(ShellError::OutsideSpannedLabeledError(
+                            original_text.to_string(),
+                            "decade duration too large".into(),
+                            "decade duration too large".into(),
+                            expr.span,
+                        )),
+                    }
+                }
             }
         }
         Expr::Var(..) => Err(ShellError::OutsideSpannedLabeledError(

crates/nu-command/src/math/floor.rs

@@ -18,6 +18,10 @@ impl Command for SubCommand {
         "Applies the floor function to a list of numbers"
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["floor"]
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,

crates/nu-command/src/math/median.rs

@@ -23,7 +23,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["middle", "average"]
+        vec!["middle", "median"]
     }
 
     fn run(

crates/nu-command/src/math/mode.rs

@@ -44,7 +44,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["common", "often", "average"]
+        vec!["common", "often"]
     }
 
     fn run(

crates/nu-command/src/math/variance.rs

@@ -21,6 +21,10 @@ impl Command for SubCommand {
         "Finds the variance of a list of numbers or tables"
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["deviation", "dispersion", "variance", "variation"]
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,

crates/nu-command/src/misc/history.rs

@@ -116,7 +116,7 @@ impl Command for History {
                                     cols: vec![
                                         "item_id".into(),
                                         "start_timestamp".into(),
-                                        "command_line".to_string(),
+                                        "command".to_string(),
                                         "session_id".into(),
                                         "hostname".into(),
                                         "cwd".into(),

crates/nu-command/src/network/port.rs

@@ -17,7 +17,7 @@ impl Command for SubCommand {
     }
 
     fn signature(&self) -> Signature {
-        Signature::build("post")
+        Signature::build("port")
             .optional(
                 "start",
                 SyntaxShape::Int,
@@ -48,7 +48,7 @@ impl Command for SubCommand {
     fn examples(&self) -> Vec<Example> {
         vec![
             Example {
-                description: "get free port between 3121 and 4000",
+                description: "get a free port between 3121 and 4000",
                 example: "port 3121 4000",
                 result: Some(Value::Int {
                     val: 3121,
@@ -56,7 +56,7 @@ impl Command for SubCommand {
                 }),
             },
             Example {
-                description: "get free port from system",
+                description: "get a free port from system",
                 example: "port",
                 result: None,
             },

crates/nu-command/src/random/uuid.rs

@@ -40,7 +40,7 @@ impl Command for SubCommand {
 
 fn uuid(call: &Call) -> Result<PipelineData, ShellError> {
     let span = call.head;
-    let uuid_4 = Uuid::new_v4().to_hyphenated().to_string();
+    let uuid_4 = Uuid::new_v4().hyphenated().to_string();
 
     Ok(PipelineData::Value(
         Value::String { val: uuid_4, span },

crates/nu-command/src/strings/size.rs

@@ -25,7 +25,7 @@ impl Command for Size {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["count", "word", "character", "unicode"]
+        vec!["count", "word", "character", "unicode", "wc"]
     }
 
     fn run(

crates/nu-command/src/strings/split/list.rs

@@ -0,0 +1,130 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    ast::Call,
+    engine::{Command, EngineState, Stack},
+    Category, Example, IntoPipelineData, PipelineData, Signature, Span, SyntaxShape, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "split list"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("split list")
+            .required(
+                "separator",
+                SyntaxShape::Any,
+                "the value that denotes what separates the list",
+            )
+            .category(Category::Filters)
+    }
+
+    fn usage(&self) -> &str {
+        "Split a list into multiple lists using a separator"
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["list", "separate", "divide"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        split_list(engine_state, stack, call, input)
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Split a list of chars into two lists",
+                example: "[a, b, c, d, e, f, g] | split list d",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::List {
+                            vals: vec![
+                                Value::test_string("a"),
+                                Value::test_string("b"),
+                                Value::test_string("c"),
+                            ],
+                            span: Span::test_data(),
+                        },
+                        Value::List {
+                            vals: vec![
+                                Value::test_string("e"),
+                                Value::test_string("f"),
+                                Value::test_string("g"),
+                            ],
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+            Example {
+                description: "Split a list of lists into two lists of lists",
+                example: "[[1,2], [2,3], [3,4]] | split list [2,3]",
+                result: Some(Value::List {
+                    vals: vec![
+                        Value::List {
+                            vals: vec![Value::List {
+                                vals: vec![Value::test_int(1), Value::test_int(2)],
+                                span: Span::test_data(),
+                            }],
+                            span: Span::test_data(),
+                        },
+                        Value::List {
+                            vals: vec![Value::List {
+                                vals: vec![Value::test_int(3), Value::test_int(4)],
+                                span: Span::test_data(),
+                            }],
+                            span: Span::test_data(),
+                        },
+                    ],
+                    span: Span::test_data(),
+                }),
+            },
+        ]
+    }
+}
+
+fn split_list(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    input: PipelineData,
+) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+    let separator: Value = call.req(engine_state, stack, 0)?;
+    let mut temp_list = Vec::new();
+    let mut returned_list = Vec::new();
+    let iter = input.into_interruptible_iter(engine_state.ctrlc.clone());
+    for val in iter {
+        if val == separator && !temp_list.is_empty() {
+            returned_list.push(Value::List {
+                vals: temp_list.clone(),
+                span: call.head,
+            });
+            temp_list = Vec::new();
+        } else {
+            temp_list.push(val);
+        }
+    }
+    if !temp_list.is_empty() {
+        returned_list.push(Value::List {
+            vals: temp_list.clone(),
+            span: call.head,
+        });
+    }
+    Ok(Value::List {
+        vals: returned_list,
+        span: call.head,
+    }
+    .into_pipeline_data())
+}

crates/nu-command/src/strings/split/mod.rs

@@ -1,9 +1,11 @@
 pub mod chars;
 pub mod column;
 pub mod command;
+pub mod list;
 pub mod row;
 
 pub use chars::SubCommand as SplitChars;
 pub use column::SubCommand as SplitColumn;
 pub use command::SplitCommand as Split;
+pub use list::SubCommand as SplitList;
 pub use row::SubCommand as SplitRow;

crates/nu-command/src/strings/str_/reverse.rs

@@ -28,7 +28,7 @@ impl Command for SubCommand {
     }
 
     fn search_terms(&self) -> Vec<&str> {
-        vec!["convert", "inverse"]
+        vec!["convert", "inverse", "flip"]
     }
 
     fn run(

crates/nu-command/src/system/ps.rs

@@ -29,6 +29,10 @@ impl Command for Ps {
         "View information about system processes."
     }
 
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["procedures", "operations", "tasks", "ops"]
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,

crates/nu-command/src/system/run_external.rs

@@ -194,9 +194,6 @@ impl ExternalCommand {
                 let (stderr_tx, stderr_rx) = mpsc::sync_channel(OUTPUT_BUFFERS_IN_FLIGHT);
                 let (exit_code_tx, exit_code_rx) = mpsc::channel();
 
-                #[cfg(unix)]
-                let (exit_status_tx, exit_status_rx) = mpsc::channel();
-
                 std::thread::spawn(move || {
                     // If this external is not the last expression, then its output is piped to a channel
                     // and we create a ListStream that can be consumed
@@ -286,9 +283,6 @@ impl ExternalCommand {
                             span,
                         )),
                         Ok(x) => {
-                            #[cfg(unix)]
-                            let _ = exit_status_tx.send(x);
-
                             if let Some(code) = x.code() {
                                 let _ = exit_code_tx.send(Value::Int {
                                     val: code as i64,
@@ -310,26 +304,6 @@ impl ExternalCommand {
                 let stderr_receiver = ChannelReceiver::new(stderr_rx);
                 let exit_code_receiver = ValueReceiver::new(exit_code_rx);
 
-                #[cfg(unix)]
-                {
-                    use signal_hook::low_level::signal_name;
-                    use std::os::unix::process::ExitStatusExt;
-                    use std::time::Duration;
-
-                    // The receiver will block 100ms if there's no sender
-                    if let Ok(status) = exit_status_rx.recv_timeout(Duration::from_millis(100)) {
-                        if status.core_dumped() {
-                            if let Some(sig) = status.signal().and_then(signal_name) {
-                                return Err(ShellError::ExternalCommand(
-                                    format!("{sig} (core dumped)"),
-                                    "Child process core dumped".to_string(),
-                                    span,
-                                ));
-                            }
-                        }
-                    }
-                }
-
                 Ok(PipelineData::ExternalStream {
                     stdout: if redirect_stdout {
                         Some(RawStream::new(
@@ -428,7 +402,7 @@ impl ExternalCommand {
 
     /// Spawn a command without shelling out to an external shell
     pub fn spawn_simple_command(&self, cwd: &str) -> Result<std::process::Command, ShellError> {
-        let head = trim_enclosing_quotes(&self.name.item);
+        let (head, _) = trim_enclosing_quotes(&self.name.item);
         let head = nu_path::expand_to_real_path(head)
             .to_string_lossy()
             .to_string();
@@ -436,8 +410,9 @@ impl ExternalCommand {
         let mut process = std::process::Command::new(&head);
 
         for arg in self.args.iter() {
+            let (trimmed_args, run_glob_expansion) = trim_enclosing_quotes(&arg.item);
             let mut arg = Spanned {
-                item: remove_quotes(trim_enclosing_quotes(&arg.item)),
+                item: remove_quotes(trimmed_args),
                 span: arg.span,
             };
 
@@ -447,7 +422,7 @@ impl ExternalCommand {
 
             let cwd = PathBuf::from(cwd);
 
-            if arg.item.contains('*') {
+            if arg.item.contains('*') && run_glob_expansion {
                 if let Ok((prefix, matches)) =
                     nu_engine::glob_from(&arg, &cwd, self.name.span, None)
                 {
@@ -542,14 +517,14 @@ fn shell_arg_escape(arg: &str) -> String {
     }
 }
 
-fn trim_enclosing_quotes(input: &str) -> String {
+fn trim_enclosing_quotes(input: &str) -> (String, bool) {
     let mut chars = input.chars();
 
     match (chars.next(), chars.next_back()) {
-        (Some('"'), Some('"')) => chars.collect(),
-        (Some('\''), Some('\'')) => chars.collect(),
-        (Some('`'), Some('`')) => chars.collect(),
-        _ => input.to_string(),
+        (Some('"'), Some('"')) => (chars.collect(), false),
+        (Some('\''), Some('\'')) => (chars.collect(), false),
+        (Some('`'), Some('`')) => (chars.collect(), true),
+        _ => (input.to_string(), true),
     }
 }
 

crates/nu-command/src/system/sys.rs

@@ -6,7 +6,7 @@ use nu_protocol::{
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Value,
 };
 use std::time::{Duration, UNIX_EPOCH};
-use sysinfo::{ComponentExt, DiskExt, NetworkExt, ProcessorExt, System, SystemExt, UserExt};
+use sysinfo::{ComponentExt, CpuExt, DiskExt, NetworkExt, System, SystemExt, UserExt};
 
 #[derive(Clone)]
 pub struct Sys;
@@ -199,7 +199,7 @@ pub fn cpu(sys: &mut System, span: Span) -> Option<Value> {
     sys.refresh_cpu();
 
     let mut output = vec![];
-    for cpu in sys.processors() {
+    for cpu in sys.cpus() {
         let mut cols = vec![];
         let mut vals = vec![];
 

crates/nu-command/tests/commands/all.rs

@@ -55,3 +55,15 @@ fn checks_all_columns_of_a_table_is_true() {
 
     assert_eq!(actual.out, "true");
 }
+
+#[test]
+fn checks_if_all_returns_error_with_invalid_command() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+            [red orange yellow green blue purple] | all? ($it | st length) > 4
+        "#
+    ));
+
+    assert!(actual.err.contains("can't run executable") || actual.err.contains("type_mismatch"));
+}

crates/nu-command/tests/commands/any.rs

@@ -31,3 +31,15 @@ fn checks_any_column_of_a_table_is_true() {
 
     assert_eq!(actual.out, "true");
 }
+
+#[test]
+fn checks_if_any_returns_error_with_invalid_command() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+            [red orange yellow green blue purple] | any? ($it | st length) > 4
+        "#
+    ));
+
+    assert!(actual.err.contains("can't run executable") || actual.err.contains("type_mismatch"));
+}

crates/nu-command/tests/commands/cp.rs

@@ -17,6 +17,22 @@ fn copies_a_file() {
     });
 }
 
+#[test]
+fn copies_multiple_files() {
+    Playground::setup("cp_test_1_1", |dirs, sandbox| {
+        sandbox
+            .with_files(vec![EmptyFile("a.txt"), EmptyFile("b.txt")])
+            .mkdir("dest");
+        nu!(
+            cwd: dirs.test(),
+            "cp a.txt b.txt dest",
+        );
+
+        assert!(dirs.test().join("dest/a.txt").exists());
+        assert!(dirs.test().join("dest/b.txt").exists());
+    });
+}
+
 #[test]
 fn copies_the_file_inside_directory_if_path_to_copy_is_directory() {
     Playground::setup("cp_test_2", |dirs, _| {

crates/nu-command/tests/commands/def.rs

@@ -1,5 +1,5 @@
-use nu_test_support::nu;
 use nu_test_support::playground::Playground;
+use nu_test_support::{nu, pipeline};
 use std::fs;
 
 #[test]
@@ -18,3 +18,15 @@ def e [arg] {echo $arg}
         assert!(actual.out.contains("My echo\\n\\n"));
     });
 }
+
+#[test]
+fn def_errors_with_multiple_short_flags() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        def test-command [ --long(-l)(-o) ] {}
+        "#
+    ));
+
+    assert!(actual.err.contains("expected one short flag"));
+}

crates/nu-command/tests/commands/error_make.rs

@@ -0,0 +1,26 @@
+use nu_test_support::{nu, pipeline};
+
+#[test]
+fn error_label_works() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        error make {msg:foo label:{text:unseen}}
+        "#
+    ));
+
+    assert!(actual.err.contains("unseen"));
+    assert!(actual.err.contains("╰──"));
+}
+
+#[test]
+fn no_span_if_unspanned() {
+    let actual = nu!(
+        cwd: ".", pipeline(
+        r#"
+        error make -u {msg:foo label:{text:unseen}}
+        "#
+    ));
+
+    assert!(!actual.err.contains("unseen"));
+}

crates/nu-command/tests/commands/ls.rs

@@ -335,6 +335,28 @@ fn lists_files_including_starting_with_dot() {
     })
 }
 
+#[test]
+fn lists_regular_files_using_multiple_asterisk_wildcards() {
+    Playground::setup("ls_test_10", |dirs, sandbox| {
+        sandbox.with_files(vec![
+            EmptyFile("los.txt"),
+            EmptyFile("tres.txt"),
+            EmptyFile("amigos.txt"),
+            EmptyFile("arepas.clu"),
+        ]);
+
+        let actual = nu!(
+            cwd: dirs.test(), pipeline(
+            r#"
+                ls *.txt *.clu
+                | length
+            "#
+        ));
+
+        assert_eq!(actual.out, "4");
+    })
+}
+
 #[test]
 fn list_all_columns() {
     Playground::setup("ls_test_all_columns", |dirs, sandbox| {
@@ -392,6 +414,74 @@ fn list_all_columns() {
     });
 }
 
+#[test]
+fn lists_with_directory_flag() {
+    Playground::setup("ls_test_flag_directory_1", |dirs, sandbox| {
+        sandbox
+            .within("dir_files")
+            .with_files(vec![EmptyFile("nushell.json")])
+            .within("dir_empty");
+        let actual = nu!(
+            cwd: dirs.test(), pipeline(
+            r#"
+                cd dir_empty;
+                ['.' '././.' '..' '../dir_files' '../dir_files/*']
+                | each { |it| ls --directory $it }
+                | flatten
+                | get name
+                | to text
+            "#
+        ));
+        let expected = [".", ".", "..", "../dir_files", "../dir_files/nushell.json"].join("");
+        #[cfg(windows)]
+        let expected = expected.replace("/", "\\");
+        assert_eq!(
+            actual.out, expected,
+            "column names are incorrect for ls --directory (-D)"
+        );
+    });
+}
+
+#[test]
+fn lists_with_directory_flag_without_argument() {
+    Playground::setup("ls_test_flag_directory_2", |dirs, sandbox| {
+        sandbox
+            .within("dir_files")
+            .with_files(vec![EmptyFile("nushell.json")])
+            .within("dir_empty");
+        // Test if there are some files in the current directory
+        let actual = nu!(
+            cwd: dirs.test(), pipeline(
+            r#"
+                cd dir_files;
+                ls --directory
+                | get name
+                | to text
+            "#
+        ));
+        let expected = ".";
+        assert_eq!(
+            actual.out, expected,
+            "column names are incorrect for ls --directory (-D)"
+        );
+        // Test if there is no file in the current directory
+        let actual = nu!(
+            cwd: dirs.test(), pipeline(
+            r#"
+                cd dir_empty;
+                ls -D
+                | get name
+                | to text
+            "#
+        ));
+        let expected = ".";
+        assert_eq!(
+            actual.out, expected,
+            "column names are incorrect for ls --directory (-D)"
+        );
+    });
+}
+
 /// Rust's fs::metadata function is unable to read info for certain system files on Windows,
 /// like the `C:\Windows\System32\Configuration` folder. https://github.com/rust-lang/rust/issues/96980
 /// This test confirms that Nu can work around this successfully.

crates/nu-command/tests/commands/math/mod.rs

@@ -291,7 +291,7 @@ fn duration_math() {
         "#
     ));
 
-    assert_eq!(actual.out, "8day");
+    assert_eq!(actual.out, "1wk 1day");
 }
 
 #[test]
@@ -315,7 +315,7 @@ fn duration_math_with_nanoseconds() {
         "#
     ));
 
-    assert_eq!(actual.out, "7day 10ns");
+    assert_eq!(actual.out, "1wk 10ns");
 }
 
 #[test]
@@ -327,7 +327,22 @@ fn duration_decimal_math_with_nanoseconds() {
         "#
     ));
 
-    assert_eq!(actual.out, "10day 10ns");
+    assert_eq!(actual.out, "1wk 3day 10ns");
+}
+
+#[test]
+fn duration_decimal_math_with_all_units() {
+    let actual = nu!(
+        cwd: "tests/fixtures/formats", pipeline(
+        r#"
+            5dec + 3yr + 2month + 1wk + 3day + 8hr + 10min + 16sec + 121ms + 11us + 12ns
+        "#
+    ));
+
+    assert_eq!(
+        actual.out,
+        "53yr 2month 1wk 3day 8hr 10min 16sec 121ms 11µs 12ns"
+    );
 }
 
 #[test]

crates/nu-command/tests/commands/mod.rs

@@ -15,6 +15,7 @@ mod each;
 mod echo;
 mod empty;
 mod enter;
+mod error_make;
 mod every;
 mod find;
 mod first;

crates/nu-command/tests/commands/move_/mv.rs

@@ -22,6 +22,36 @@ fn moves_a_file() {
     })
 }
 
+#[test]
+fn moves_multiple_files() {
+    Playground::setup("mv_test_1_1", |dirs, sandbox| {
+        sandbox
+            .mkdir("expected")
+            .with_files(vec![EmptyFile("andres.txt"), EmptyFile("yehuda.txt")])
+            .within("foo")
+            .with_files(vec![EmptyFile("bar.txt")]);
+
+        let original_1 = dirs.test().join("andres.txt");
+        let original_2 = dirs.test().join("yehuda.txt");
+        let original_3 = dirs.test().join("foo/bar.txt");
+        let expected_1 = dirs.test().join("expected/andres.txt");
+        let expected_2 = dirs.test().join("expected/yehuda.txt");
+        let expected_3 = dirs.test().join("expected/bar.txt");
+
+        nu!(
+            cwd: dirs.test(),
+            "mv andres.txt yehuda.txt foo/bar.txt expected"
+        );
+
+        assert!(!original_1.exists());
+        assert!(!original_2.exists());
+        assert!(!original_3.exists());
+        assert!(expected_1.exists());
+        assert!(expected_2.exists());
+        assert!(expected_3.exists());
+    })
+}
+
 #[test]
 fn overwrites_if_moving_to_existing_file() {
     Playground::setup("mv_test_2", |dirs, sandbox| {

crates/nu-command/tests/commands/network/port.rs

@@ -16,26 +16,35 @@ fn port_with_invalid_range() {
 
 #[test]
 fn port_with_already_usage() {
-    let (tx, rx) = mpsc::sync_channel(0);
+    let retry_times = 10;
+    for _ in 0..retry_times {
+        let (tx, rx) = mpsc::sync_channel(0);
 
-    // let system pick a free port for us.
-    let free_port = {
-        let listener = TcpListener::bind("127.0.0.1:0").expect("failed to pick a port");
-        listener.local_addr().unwrap().port()
-    };
-    let handler = std::thread::spawn(move || {
-        let _listener = TcpListener::bind(format!("127.0.0.1:{free_port}"));
-        let _ = rx.recv();
-    });
-    let actual = nu!(
-        cwd: ".", pipeline(&format!("port {free_port} {free_port}"))
+        // let system pick a free port for us.
+        let free_port = {
+            let listener = TcpListener::bind("127.0.0.1:0").expect("failed to pick a port");
+            listener.local_addr().unwrap().port()
+        };
+        let handler = std::thread::spawn(move || {
+            let _listener = TcpListener::bind(format!("127.0.0.1:{free_port}"));
+            let _ = rx.recv();
+        });
+        let actual = nu!(
+            cwd: ".", pipeline(&format!("port {free_port} {free_port}"))
+        );
+        let _ = tx.send(true);
+        // make sure that the thread is closed and we release the port.
+        handler.join().unwrap();
+
+        // check for error kind str.
+        if actual.err.contains("AddrInUse") {
+            return;
+        }
+    }
+    assert!(
+        false,
+        "already check port report AddrInUse for seveval times, but still failed."
     );
-    let _ = tx.send(true);
-    // make sure that the thread is closed and we release the port.
-    handler.join().unwrap();
-
-    // check for error kind str.
-    assert!(actual.err.contains("AddrInUse"))
 }
 
 #[test]