Struct InteractBuilder 

pub struct InteractBuilder<'a, T>
where
    T: AsyncReadExt + AsyncWriteExt + Unpin + Send + 'static,
{ /* private fields */ }

Builder for configuring interactive sessions.

Implementations

impl<'a, T> InteractBuilder<'a, T>

where T: AsyncReadExt + AsyncWriteExt + Unpin + Send + 'static,

pub fn on_output<F>(self, pattern: impl Into<Pattern>, callback: F) -> Self

where F: Fn(&InteractContext<'_>) -> InteractAction + Send + Sync + 'static,

Register a pattern hook for output.

When the output matches the pattern, the callback is invoked.

Example

session.interact()
    .on_output("password:", |ctx| {
        ctx.send("my_password\n")
    })
    .start()
    .await?;

pub fn on_input<F>(self, pattern: impl Into<Pattern>, callback: F) -> Self

where F: Fn(&InteractContext<'_>) -> InteractAction + Send + Sync + 'static,

Register a pattern hook for input.

When the input matches the pattern, the callback is invoked.

pub fn on_resize<F>(self, callback: F) -> Self

where F: Fn(&ResizeContext) -> InteractAction + Send + Sync + 'static,

Register a hook for terminal resize events.

On Unix systems, this is triggered by SIGWINCH. The callback receives the new terminal size and can optionally return an action.

Example

session.interact()
    .on_resize(|ctx| {
        println!("Terminal resized to {}x{}", ctx.size.cols, ctx.size.rows);
        InteractAction::Continue
    })
    .start()
    .await?;

Platform Support

• Unix: Resize events are detected via SIGWINCH signal handling.
• Windows: Resize detection is not currently supported; the callback will not be invoked.

pub const fn with_mode(self, mode: InteractionMode) -> Self

Set the interaction mode.

pub fn with_escape(self, escape: impl Into<Vec<u8>>) -> Self

Set the escape sequence to exit interact mode.

Default is Ctrl+] (0x1d).

pub fn no_escape(self) -> Self

Disable the escape sequence (interact runs until pattern stops it).

pub const fn with_timeout(self, timeout: Duration) -> Self

Set a timeout for the interaction.

pub const fn with_buffer_size(self, size: usize) -> Self

Set the output buffer size.

pub fn with_input_hook<F>(self, hook: F) -> Self

where F: Fn(&[u8]) -> Vec<u8> + Send + Sync + 'static,

Add a byte-level input hook.

pub fn with_output_hook<F>(self, hook: F) -> Self

where F: Fn(&[u8]) -> Vec<u8> + Send + Sync + 'static,

Add a byte-level output hook.

pub async fn start(self) -> Result<InteractResult>

Start the interactive session.

This runs the interaction loop, reading from stdin and the session, checking patterns, and invoking callbacks when matches occur.

The interaction continues until:

• A pattern callback returns InteractAction::Stop
• The escape sequence is detected
• A timeout occurs (if configured)
• EOF is reached on the session

Errors

Returns an error if I/O fails or a pattern callback returns an error.