Nu Plugin

https://docs.rs/nu-plugin/latest/
Admin
Nu Plugin is a Rust library that provides the interface and tools necessary to build stand-alone...
Tokens:58,739
Snippets:693
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Define examples for SimplePluginCommand

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/command.rs.html?search=std%3A%3Avec

The examples method returns a vector of Example objects demonstrating command usage, which can be validated using PluginTest::test_command_examples.

```rust
fn examples(&self) -> Vec<Example<'_>> {
        vec![]
    }
```

--------------------------------

### serve_plugin main entry point example

Source: https://docs.rs/nu-plugin/latest/nu_plugin/fn.serve_plugin.html?search=u32+-%3E+bool

An example of using serve_plugin within the main function of a plugin, utilizing a custom plugin instance and the MsgPackSerializer.

```rust
fn main() {
   serve_plugin(&MyPlugin::new(), MsgPackSerializer)
}
```

--------------------------------

### fn examples(&self) -> Vec<Example<'_>>

Source: https://docs.rs/nu-plugin/latest/nu_plugin/trait.SimplePluginCommand.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides usage examples for the command, which can be verified using the plugin test support crate.

```APIDOC
### fn examples(&self) -> Vec<Example<'_>>

Returns a list of examples demonstrating how the command might be used in Nu pipelines.
```

--------------------------------

### get_help example

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the help string for the current command.

```rust
eprintln!("{}", engine.get_help()?);
```

--------------------------------

### Render Plugin Examples

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/command.rs.html?search=

Converts custom values within command examples to their base representation for engine communication.

```rust
pub(crate) fn render_examples(
    plugin: &impl Plugin,
    engine: &EngineInterface,
    examples: &mut [PluginExample],
) -> Result<(), ShellError> {
    for example in examples {
        if let Some(ref mut value) = example.result {
            value.recurse_mut(&mut |value| {
                let span = value.span();
                match value {
                    Value::Custom { .. } => {
                        let value_taken = std::mem::replace(value, Value::nothing(span));
                        let Value::Custom { val, .. } = value_taken else {
                            unreachable!()
                        };
                        *value =
                            plugin.custom_value_to_base_value(engine, val.into_spanned(span))?;
                        Ok::<_, ShellError>(())
                    }
                    _ => Ok(()),
                }
            })?;
        }
    }
    Ok(())
}
```

--------------------------------

### get_plugin_config example

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Prints the plugin-specific configuration stored in $env.config.plugins.NAME.

```rust
let config = engine.get_plugin_config()?;
eprintln!("{:?}", config);
```

--------------------------------

### Get Engine Configuration

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/interface/mod.rs.html?search=

Retrieves the full shell configuration from the engine. This example demonstrates formatting a value using the user's preferred configuration.

```rust
use nu_protocol::{Value, ShellError};
use nu_plugin::EngineInterface;
fn example(engine: &EngineInterface, value: &Value) -> Result<(), ShellError> {
let config = engine.get_config()?;
eprintln!("{}", value.to_expanded_string(", ", &config));
Ok(())
}
```

--------------------------------

### get_config example

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the full shell configuration to format values.

```rust
let config = engine.get_config()?;
eprintln!("{}", value.to_expanded_string(", ", &config));
```

--------------------------------

### Basic Plugin Implementation

Source: https://docs.rs/nu-plugin/latest/nu_plugin/trait.Plugin.html

A complete example showing how to implement the Plugin trait and a SimplePluginCommand for a basic 'hello' command.

```rust
struct HelloPlugin;
struct Hello;

impl Plugin for HelloPlugin {
    fn version(&self) -> String {
        env!("CARGO_PKG_VERSION").into()
    }

    fn commands(&self) -> Vec<Box<dyn PluginCommand<Plugin=Self>>> {
        vec![Box::new(Hello)]
    }
}

impl SimplePluginCommand for Hello {
    type Plugin = HelloPlugin;

    fn name(&self) -> &str {
        "hello"
    }

    fn description(&self) -> &str {
        "Every programmer's favorite greeting"
    }

    fn signature(&self) -> Signature {
        Signature::build(PluginCommand::name(self))
            .input_output_type(Type::Nothing, Type::String)
    }

    fn run(
        &self,
        plugin: &HelloPlugin,
        engine: &EngineInterface,
        call: &EvaluatedCall,
        input: &Value,
    ) -> Result<Value, LabeledError> {
        Ok(Value::string("Hello, World!".to_owned(), call.head))
    }
}
```

--------------------------------

### Implementing a Basic SimplePluginCommand

Source: https://docs.rs/nu-plugin/latest/nu_plugin/trait.SimplePluginCommand.html?search=

An example demonstrating how to implement the SimplePluginCommand trait for a custom command named 'hello'.

```rust
struct HelloPlugin;
struct Hello;

impl SimplePluginCommand for Hello {
    type Plugin = HelloPlugin;

    fn name(&self) -> &str {
        "hello"
    }

    fn description(&self) -> &str {
        "Every programmer's favorite greeting"
    }

    fn signature(&self) -> Signature {
        Signature::build(PluginCommand::name(self))
            .input_output_type(Type::Nothing, Type::String)
    }

    fn run(
        &self,
        plugin: &HelloPlugin,
        engine: &EngineInterface,
        call: &EvaluatedCall,
        input: &Value,
    ) -> Result<Value, LabeledError> {
        Ok(Value::string("Hello, World!".to_owned(), call.head))
    }
}
```

--------------------------------

### Implement main entry point for a Nushell plugin

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/mod.rs.html?search=

This example demonstrates how to use the serve_plugin function within the main entry point of a Nushell plugin.

```rust
# use nu_plugin::*;
# use nu_protocol::{PluginSignature, Value};
# struct MyPlugin;
# impl MyPlugin { fn new() -> Self { Self }}
# impl Plugin for MyPlugin {
#     fn version(&self) -> String { "0.0.0".into() }
#     fn commands(&self) -> Vec<Box<dyn PluginCommand<Plugin=Self>>> {todo!();}
# }
fn main() {
   serve_plugin(&MyPlugin::new(), MsgPackSerializer)
}
```

--------------------------------

### get_env_vars example

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves all environment variables from the engine.

```rust
engine.get_env_vars() // => Ok({"PATH": Value::List([...]), ...})
```

--------------------------------

### PluginCommand trait methods

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/command.rs.html

Definitions for the examples, run, and get_dynamic_completion methods within the PluginCommand trait.

```rust
    fn examples(&self) -> Vec<Example<'_>> {
        vec![]
    }

    fn run(
        &self,
        plugin: &Self::Plugin,
        engine: &EngineInterface,
        call: &EvaluatedCall,
        input: PipelineData,
    ) -> Result<PipelineData, LabeledError>;

    #[allow(unused_variables)]
    fn get_dynamic_completion(
        &self,
        plugin: &Self::Plugin,
        engine: &EngineInterface,
        call: DynamicCompletionCall,
        arg_type: ArgType,
        _experimental: nu_protocol::engine::ExperimentalMarker,
    ) -> Option<Vec<DynamicSuggestion>> {
        None
    }
```

--------------------------------

### Implement PluginCommand for a custom command

Source: https://docs.rs/nu-plugin/latest/nu_plugin/trait.PluginCommand.html

An example implementation of the PluginCommand trait for a 'lowercase' command, demonstrating how to define the command's name, description, signature, and stream-based execution logic.

```rust
struct LowercasePlugin;
struct Lowercase;

impl PluginCommand for Lowercase {
    type Plugin = LowercasePlugin;

    fn name(&self) -> &str {
        "lowercase"
    }

    fn description(&self) -> &str {
        "Convert each string in a stream to lowercase"
    }

    fn signature(&self) -> Signature {
        Signature::build(PluginCommand::name(self))
            .input_output_type(Type::List(Type::String.into()), Type::List(Type::String.into()))
    }

    fn run(
        &self,
        plugin: &LowercasePlugin,
        engine: &EngineInterface,
        call: &EvaluatedCall,
        input: PipelineData,
    ) -> Result<PipelineData, LabeledError> {
        let span = call.head;
        Ok(input.map(move |value| {
            value.as_str()
                .map(|string| Value::string(string.to_lowercase(), span))
                // Errors in a stream should be returned as values.
                .unwrap_or_else(|err| Value::error(err, span))
        }, &Signals::empty())?)
    }
}
```

--------------------------------

### Write Plugin Signatures

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/interface/mod.rs.html?search=

Writes a call response containing plugin signatures. Custom values in examples are rendered using to_base_value().

```rust
pub(crate) fn write_signature(
        &self,
        signature: Vec<PluginSignature>,
    ) -> Result<(), ShellError> {
        let response = PluginCallResponse::Signature(signature);
        self.write(PluginOutput::CallResponse(self.context()?, response))?;
        self.flush()
    }
```

--------------------------------

### Evaluate closure with stream using eval_closure_with_stream

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/interface/mod.rs.html?search=std%3A%3Avec

Demonstrates how to invoke a closure and process its output as a stream. The example shows the Nushell invocation and the corresponding Rust implementation.

```nushell
my_command { seq 1 $in | each { |n| $"Hello, ($n)" } }
```

```rust
# use nu_protocol::{Value, ShellError, PipelineData};
# use nu_plugin::{EngineInterface, EvaluatedCall};
# fn example(engine: &EngineInterface, call: &EvaluatedCall) -> Result<(), ShellError> {
let closure = call.req(0)?;
let input = PipelineData::value(Value::int(4, call.head), None);
let output = engine.eval_closure_with_stream(
    &closure,
    vec![],
    input,
    true,
    false,
)?;
for value in output {
    eprintln!("Closure says: {}", value.as_str()?);
}
# Ok(())
# }
```

```text
Closure says: Hello, 1
Closure says: Hello, 2
Closure says: Hello, 3
Closure says: Hello, 4
```

--------------------------------

### get_env_var example

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the value of a specific environment variable.

```rust
engine.get_env_var("PATH") // => Ok(Some(Value::List([...])))
```

--------------------------------

### serve_plugin

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes and runs the plugin. This function should be called in the main function of a plugin binary.

```APIDOC
## serve_plugin(plugin: &impl Plugin, encoder: impl PluginEncoder + 'static)

### Description
Initializes the plugin and starts the communication loop with Nushell. It handles command-line arguments to determine the communication mode (stdio or local socket) and manages the plugin lifecycle.

### Parameters
- **plugin** (&impl Plugin) - The plugin implementation instance.
- **encoder** (impl PluginEncoder + 'static) - The encoder used for serializing plugin communication.

### Usage Example
```rust
fn main() {
    serve_plugin(&MyPlugin::new(), MsgPackSerializer)
}
```
```

--------------------------------

### add_env_var example

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets an environment variable in the caller's scope.

```rust
engine.add_env_var("FOO", Value::test_string("bar"))
```

--------------------------------

### get_current_dir example

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the current working directory as an absolute path.

```rust
engine.get_current_dir() // => "/home/user"
```

--------------------------------

### Format Command Help String

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/mod.rs.html

Constructs a help message by sequentially writing command metadata, flags, and positional arguments to a buffer. It handles required, optional, and rest positional parameters before printing the final result.

```rust
let res = write!(help, "\nCommand: {}", command.name())
    .and_then(|_| writeln!(help, "\nDescription:\n > {}", command.description()))
    .and_then(|_| {
        if !command.extra_description().is_empty() {
            writeln!(
                help,
                "\nExtra description:\n > {}",
                command.extra_description()
            )
        } else {
            Ok(())
        }
    })
    .and_then(|_| {
        let flags = get_flags_section(&signature, &help_style, |v| match v {
            FormatterValue::DefaultValue(value) => format!("{value:#?}"),
            FormatterValue::CodeString(text) => text.to_string(),
        });
        write!(help, "{flags}")
    })
    .and_then(|_| writeln!(help, "\nParameters:"))
    .and_then(|_| {
        signature
            .required_positional
            .iter()
            .try_for_each(|positional| {
                writeln!(
                    help,
                    "  {} <{}>: {}",
                    positional.name, positional.shape, positional.desc
                )
            })
    })
    .and_then(|_| {
        signature
            .optional_positional
            .iter()
            .try_for_each(|positional| {
                writeln!(
                    help,
                    "  (optional) {} <{}>: {}",
                    positional.name, positional.shape, positional.desc
                )
            })
    })
    .and_then(|_| {
        if let Some(rest_positional) = &signature.rest_positional {
            writeln!(
                help,
                "  ...{} <{}>: {}",
                rest_positional.name, rest_positional.shape, rest_positional.desc
            )
        } else {
            Ok(())
        }
    })
    .and_then(|_| writeln!(help, "======================"));

if res.is_err() {
    println!("{res:?}")
}
});

println!("{help}")
}
```

--------------------------------

### Get positional argument by index

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EvaluatedCall.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a positional argument at a specific index.

```rust
let arg = match call.nth(1) {
    Some(Value::String { val, .. }) => val,
    _ => panic!(),
};
assert_eq!(arg, "b".to_owned());

let arg = call.nth(7);
assert!(arg.is_none());
```

--------------------------------

### Implementing version()

Source: https://docs.rs/nu-plugin/latest/nu_plugin/trait.Plugin.html

The recommended implementation for the version method, which retrieves the version string from the crate's Cargo.toml file.

```rust
fn version(&self) -> String {
    env!("CARGO_PKG_VERSION").into()
}
```

--------------------------------

### Format a value using engine configuration

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/interface/mod.rs.html?search=std%3A%3Avec

Demonstrates how to retrieve the user's shell configuration from the engine and use it to format a value as a string.

```rust
# use nu_protocol::{Value, ShellError};
# use nu_plugin::EngineInterface;
# fn example(engine: &EngineInterface, value: &Value) -> Result<(), ShellError> {
let config = engine.get_config()?;
eprintln!("{}", value.to_expanded_string(", ", &config));
# Ok(())
# }
```

--------------------------------

### Get flag value from EvaluatedCall

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EvaluatedCall.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the value of an optional named argument.

```rust
let opt_foo = match call.get_flag_value("foo") {
    Some(Value::Int { val, .. }) => Some(val),
    None => None,
    _ => panic!(),
};
assert_eq!(opt_foo, Some(123));
```

```rust
let opt_foo = match call.get_flag_value("foo") {
    Some(Value::Int { val, .. }) => Some(val),
    None => None,
    _ => panic!(),
};
assert_eq!(opt_foo, None);
```

--------------------------------

### Print Plugin Help Information

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/mod.rs.html?search=

Displays plugin metadata including the encoder name, version, file path, and command signatures.

```rust
fn print_help(plugin: &impl Plugin, encoder: impl PluginEncoder) {
    use std::fmt::Write;

    println!("Nushell Plugin");
    println!("Encoder: {}", encoder.name());
    println!("Version: {}", plugin.version());

    // Determine the plugin name
    let exe = std::env::current_exe().ok();
    let plugin_name: String = exe
        .as_ref()
        .map(|stem| stem.to_string_lossy().into_owned())
        .unwrap_or_else(|| "(unknown)".into());
    println!("Plugin file path: {plugin_name}");

    let mut help = String::new();
    let help_style = HelpStyle::default();

    plugin.commands().into_iter().for_each(|command| {
        let signature = command.signature();
        let res = write!(help, "\nCommand: {}", command.name())
            .and_then(|_| writeln!(help, "\nDescription:\n > {}", command.description()))
            .and_then(|_| {
```

--------------------------------

### Get Plugin Configuration

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/interface/mod.rs.html?search=std%3A%3Avec

Retrieves plugin-specific configuration from the engine, typically located at $env.config.plugins.NAME.

```rust
# use nu_protocol::{Value, ShellError};
# use nu_plugin::EngineInterface;
# fn example(engine: &EngineInterface, value: &Value) -> Result<(), ShellError> {
let config = engine.get_plugin_config()?;
eprintln!("{:?}", config);
# Ok(())
# }
```

--------------------------------

### fn version(&self) -> String

Source: https://docs.rs/nu-plugin/latest/nu_plugin/trait.Plugin.html?search=u32+-%3E+bool

Returns the version of the plugin, typically sourced from the crate's Cargo.toml file.

```APIDOC
### fn version(&self) -> String

Returns the version of the plugin as a String. It is recommended to use `env!("CARGO_PKG_VERSION").into()` to automatically sync with the crate version.
```

--------------------------------

### enter_foreground

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=u32+-%3E+bool

Moves the plugin to the foreground.

```APIDOC
## pub fn enter_foreground(&self) -> Result<ForegroundGuard, ShellError>

### Description
Returns a guard that will keep the plugin in the foreground as long as the guard is alive. Necessary for plugins that need to receive input and signals directly from the terminal.
```

--------------------------------

### Check flag status in EvaluatedCall

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EvaluatedCall.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of checking if a flag is set or passed a boolean value.

```rust
assert!(call.has_flag("foo").unwrap());
```

```rust
assert!(!call.has_flag("foo").unwrap());
```

```rust
assert!(call.has_flag("foo").unwrap());
```

```rust
assert!(!call.has_flag("foo").unwrap());
```

```rust
assert!(call.has_flag("foo").is_err());
```

--------------------------------

### get_help

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=u32+-%3E+bool

Retrieves the help string for the current command.

```APIDOC
## pub fn get_help(&self) -> Result<String, ShellError>

### Description
Get the help string for the current command.
```

--------------------------------

### Print Plugin Help Information

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/mod.rs.html

The print_help function displays plugin metadata, including the encoder name, version, and the executable file path.

```rust
fn print_help(plugin: &impl Plugin, encoder: impl PluginEncoder) {
    use std::fmt::Write;

    println!("Nushell Plugin");
    println!("Encoder: {}", encoder.name());
    println!("Version: {}", plugin.version());

    // Determine the plugin name
    let exe = std::env::current_exe().ok();
    let plugin_name: String = exe
        .as_ref()
        .map(|stem| stem.to_string_lossy().into_owned())
        .unwrap_or_else(|| "(unknown)".into());
    println!("Plugin file path: {plugin_name}");

    let mut help = String::new();
    let help_style = HelpStyle::default();

    plugin.commands().into_iter().for_each(|command| {
        let signature = command.signature();
```

--------------------------------

### Get Environment Variable

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/interface/mod.rs.html?search=std%3A%3Avec

Retrieves a specific environment variable from the engine. Returns Some(value) if found, otherwise None.

```rust
# use nu_protocol::{Value, ShellError};
# use nu_plugin::EngineInterface;
# fn example(engine: &EngineInterface) -> Result<Option<Value>, ShellError> {
engine.get_env_var("PATH") // => Ok(Some(Value::List([...])))
# }
```

--------------------------------

### Retrieve flag with get_flag

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EvaluatedCall.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a named flag as type T. This example shows successful retrieval when the flag is present.

```rust
let foo = call.get_flag::<i64>("foo");
assert_eq!(foo.unwrap(), Some(123));
```

--------------------------------

### serve_plugin

Source: https://docs.rs/nu-plugin/latest/nu_plugin/fn.serve_plugin.html?search=

The serve_plugin function is used to initialize and run a plugin, handling the communication protocol between the plugin and Nushell.

```APIDOC
## serve_plugin

### Description
Implements the communication protocol between Nushell and an external plugin. This function is typically called within the main entry point of a plugin implementation.

### Signature
`pub fn serve_plugin(plugin: &impl Plugin, encoder: impl PluginEncoder + 'static)`

### Parameters
- **plugin** (&impl Plugin) - The plugin instance to be served.
- **encoder** (impl PluginEncoder + 'static) - The encoder used for serializing plugin communication.

### Example
```rust
fn main() {
   serve_plugin(&MyPlugin::new(), MsgPackSerializer)
}
```

--------------------------------

### Generate Plugin Help Message

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/mod.rs.html?search=

This snippet demonstrates the chain of operations used to build a help string for a command, including formatting flags and positional arguments.

```rust
                if !command.extra_description().is_empty() {
                    writeln!(
                        help,
                        "\nExtra description:\n > {}",
                        command.extra_description()
                    )
                } else {
                    Ok(())
                }
            })
            .and_then(|_| {
                let flags = get_flags_section(&signature, &help_style, |v| match v {
                    FormatterValue::DefaultValue(value) => format!("{value:#?}"),
                    FormatterValue::CodeString(text) => text.to_string(),
                });
                write!(help, "{flags}")
            })
            .and_then(|_| writeln!(help, "\nParameters:"))
            .and_then(|_| {
                signature
                    .required_positional
                    .iter()
                    .try_for_each(|positional| {
                        writeln!(
                            help,
                            "  {} <{}>: {}",
                            positional.name, positional.shape, positional.desc
                        )
                    })
            })
            .and_then(|_| {
                signature
                    .optional_positional
                    .iter()
                    .try_for_each(|positional| {
                        writeln!(
                            help,
                            "  (optional) {} <{}>: {}",
                            positional.name, positional.shape, positional.desc
                        )
                    })
            })
            .and_then(|_| {
                if let Some(rest_positional) = &signature.rest_positional {
                    writeln!(
                        help,
                        "  ...{} <{}>: {}",
                        rest_positional.name, rest_positional.shape, rest_positional.desc
                    )
                } else {
                    Ok(())
                }
            })
            .and_then(|_| writeln!(help, "======================"));

        if res.is_err() {
            println!("{res:?}")
        }
    });

    println!("{help}")
}
```

--------------------------------

### eval_closure_with_stream usage

Source: https://docs.rs/nu-plugin/latest/nu_plugin/struct.EngineInterface.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Evaluates a closure with stream input and output. The example shows invoking a command with a closure and processing the resulting stream.

```text
my_command { seq 1 $in | each { |n| $"Hello, ($n)" } }
```

```rust
let closure = call.req(0)?;
let input = PipelineData::value(Value::int(4, call.head), None);
let output = engine.eval_closure_with_stream(
    &closure,
    vec![],
    input,
    true,
    false,
)?;
for value in output {
    eprintln!("Closure says: {}", value.as_str()?);
}
```

```text
Closure says: Hello, 1
Closure says: Hello, 2
Closure says: Hello, 3
Closure says: Hello, 4
```

--------------------------------

### SimplePluginCommand to PluginCommand Implementation

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/command.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This implementation allows any SimplePluginCommand to function as a PluginCommand, automatically consuming input streams.

```rust
impl<T> PluginCommand for T
where
    T: SimplePluginCommand,
{
    type Plugin = <Self as SimplePluginCommand>::Plugin;

    fn examples(&self) -> Vec<Example<'_>> {
        <Self as SimplePluginCommand>::examples(self)
    }

    fn extra_description(&self) -> &str {
        <Self as SimplePluginCommand>::extra_description(self)
    }

    fn name(&self) -> &str {
        <Self as SimplePluginCommand>::name(self)
    }

    fn run(
        &self,
        plugin: &Self::Plugin,
        engine: &EngineInterface,
        call: &EvaluatedCall,
        input: PipelineData,
    ) -> Result<PipelineData, LabeledError> {
        // Unwrap the PipelineData from input, consuming the potential stream, and pass it to the
```

--------------------------------

### fn extra_description(&self) -> &str

Source: https://docs.rs/nu-plugin/latest/nu_plugin/trait.SimplePluginCommand.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides additional, multi-line documentation for the command to be displayed in help pages.

```APIDOC
### fn extra_description(&self) -> &str

Provides additional documentation for usage of the command. This is optional and useful for explaining details that span multiple lines.
```

--------------------------------

### fn commands(&self) -> Vec<Box<dyn PluginCommand<Plugin = Self>>>

Source: https://docs.rs/nu-plugin/latest/nu_plugin/trait.Plugin.html?search=u32+-%3E+bool

Returns the list of commands supported by the plugin. This method is invoked once at plugin startup.

```APIDOC
### fn commands(&self) -> Vec<Box<dyn PluginCommand<Plugin = Self>>>

Returns a vector of boxed `PluginCommand` objects. These commands define the functionality and signatures available to the user. This method is called once by `serve_plugin` and cannot be modified at runtime.
```

--------------------------------

### Define search_terms for SimplePluginCommand

Source: https://docs.rs/nu-plugin/latest/src/nu_plugin/plugin/command.rs.html?search=std%3A%3Avec

The search_terms method returns a vector of strings used to help users find the command via help --find.

```rust
fn search_terms(&self) -> Vec<&str> {
        vec![]
    }
```

--------------------------------

### serve_plugin

Source: https://docs.rs/nu-plugin/latest/nu_plugin/fn.serve_plugin.html

The serve_plugin function initializes the communication protocol between Nushell and an external plugin. It is typically called within the main function of a plugin implementation.

```APIDOC
## serve_plugin

### Description
Initializes the communication protocol between Nushell and an external plugin. This function acts as the main entry point for plugin execution.

### Signature
`pub fn serve_plugin(plugin: &impl Plugin, encoder: impl PluginEncoder + 'static)`

### Usage Example
```rust
fn main() {
   serve_plugin(&MyPlugin::new(), MsgPackSerializer)
}
```
```
Tokens:
Raw