Struct TerminalApp 

pub struct TerminalApp {
    pub stdout_handle: Stdout,
    pub command_history: Vec<String>,
    pub current_input: String,
    pub history_index: Option<usize>,
    pub last_ctrl_c: Option<Instant>,
    pub cursor_position: usize,
    pub should_exit: bool,
    pub action_sender: Option<UnboundedSender<AppAction>>,
    /* private fields */
}

Main terminal application structure managing state and command execution.

TerminalApp provides a complete terminal interface with:

• Command history navigation
• Cursor management
• Custom command registration (sync and async)
• Configurable unknown command handling
• Non-blocking async command execution

Fields

stdout_handle: Stdout

command_history: Vec<String>

current_input: String

history_index: Option<usize>

last_ctrl_c: Option<Instant>

cursor_position: usize

should_exit: bool

action_sender: Option<UnboundedSender<AppAction>>

Implementations

impl TerminalApp

pub fn new() -> Self

Creates a new terminal application instance with default settings.

Examples found in repository

demo/main.rs (line 7)

async fn main() {
    let mut app = TerminalApp::new();
    register_commands(&mut app).await;
    let _ = app
        .run(&get_info!("App demo starting...", "Demo"), "")
        .await;
}

pub fn register_command<S: Into<String>>( &mut self, name: S, handler: Box<dyn CommandHandler>, )

Registers a synchronous command handler with the application.

Arguments

• name - Command name that users will type
• handler - Boxed command handler implementing CommandHandler

pub fn register_async_command<S: Into<String>>( &mut self, name: S, handler: Box<dyn AsyncCommandHandler>, )

Registers an asynchronous command handler with the application.

Arguments

• name - Command name that users will type
• handler - Boxed async command handler implementing AsyncCommandHandler

Examples found in repository

demo/main.rs (line 15)

async fn register_commands(app: &mut TerminalApp) {
    app.register_async_command("register", Box::new(RegisterCommand {}));
}

pub fn set_unknown_command_handler<F>(&mut self, handler: F)

where F: Fn(&str) -> String + Send + Sync + 'static,

Sets a custom handler for unknown commands (synchronous).

Arguments

• handler - Closure that takes the full command string and returns a response

pub fn set_async_unknown_command_handler<F>(&mut self, handler: F)

where F: Fn(&str) -> BoxFuture<'static, String> + Send + Sync + 'static,

Sets a custom handler for unknown commands (asynchronous).

Arguments

• handler - Closure that takes the full command string and returns a future

pub fn clear_unknown_command_handler(&mut self)

Removes the custom unknown command handler.

pub async fn init_terminal( &mut self, startup_message: &str, ) -> Result<(), Box<dyn Error>>

Initializes the terminal with raw mode and displays startup messages.

Arguments

• startup_message - Message to display on startup

Errors

Returns an error if terminal initialization fails.

pub async fn process_event( &mut self, event: Event, ) -> Result<bool, Box<dyn Error>>

Processes a single terminal event and returns whether the app should quit.

Arguments

• event - Terminal event to process
• stdout - Mutable reference to standard output

Returns

Ok(true) if the application should exit, Ok(false) otherwise

Errors

Returns an error if event processing fails.

pub async fn shutdown_terminal( &mut self, exit_message: &str, ) -> Result<(), Box<dyn Error>>

Shuts down the terminal and displays exit messages.

Arguments

• stdout - Mutable reference to standard output
• exit_message - Message to display on exit

Errors

Returns an error if terminal shutdown fails.

pub async fn run( &mut self, startup_message: &str, exit_message: &str, ) -> Result<(), Box<dyn Error>>

Main application loop that handles terminal input and command execution.

Initializes terminal event handling, processes keyboard input, and manages command execution until exit is requested. Handles special key combinations like Ctrl+C for graceful shutdown.

Arguments

• startup_message - Optional message to display on startup
• exit_message - Optional message to display on exit

Errors

Returns an error if terminal initialization or event handling fails.

Examples found in repository

demo/main.rs (line 10)

async fn main() {
    let mut app = TerminalApp::new();
    register_commands(&mut app).await;
    let _ = app
        .run(&get_info!("App demo starting...", "Demo"), "")
        .await;
}

pub fn clear_input_line(&mut self)

Clear the current input line and re-renders it.

pub fn print_log_entry(&mut self, log_line: &str)

Prints a log entry while preserving the input line.

Clears the current line, prints the log message, and re-renders the input line.

Arguments

• stdout - Mutable reference to standard output
• log_line - Log message to display

Errors

Returns an error if writing to stdout fails.

pub async fn handle_ctrl_d(&mut self) -> Result<bool, Box<dyn Error>>

Handles Ctrl+D key press, signaling application exit.

Returns

Ok(true) to signal the application should quit.

pub async fn handle_ctrl_c(&mut self) -> Result<(bool, String), Box<dyn Error>>

Handles Ctrl+C key press with double-press confirmation.

The first press clears input, the second press within 5 seconds exits.

Returns

Tuple of (should_quit, message_to_display)

pub async fn handle_enter_key( &mut self, input_prefix: &str, ) -> Result<bool, Box<dyn Error>>

Handles Enter key press to execute the current command.

Arguments

• stdout - Mutable reference to standard output
• input_prefix - Prefix to display before echoing the command

Errors

Returns an error if writing to stdout fails.

pub async fn execute_command(&mut self, command: &str) -> String

Executes a command by looking it up in the registered commands.

For sync commands, executes immediately and returns the result. For async commands, spawns them in the background and returns immediately.

Arguments

• command - Full command string including arguments

Returns

String output from the command execution (empty for async commands)

pub fn info(&mut self, message: &str)

Log info-level messages.

This method ensures proper terminal line management by clearing the current input line, printing the log message, and then re-rendering the input line.

Arguments

• message - The message content to be logged.

Examples

use daemon_console::TerminalApp;

fn main() {
    let mut app = TerminalApp::new();
    app.info("Application started successfully!");
    app.info("Running tasks...");
}

pub fn debug(&mut self, message: &str)

Log debug-level messages.

Examples

use daemon_console::TerminalApp;

fn main() {
    let mut app = TerminalApp::new();
    app.debug("Debugging information...");
    app.debug("Debugging more...");
}

pub fn warn(&mut self, message: &str)

Log warn-level messages.

Examples

use daemon_console::TerminalApp;

fn main() {
    let mut app = TerminalApp::new();
    app.warn("You get a warning!");
    app.warn("Continue running...");
}

pub fn error(&mut self, message: &str)

Log error-level messages.

Examples

use daemon_console::TerminalApp;

fn main() {
    let mut app = TerminalApp::new();
    app.error("An error occurred!");
    app.error("Failed to run tasks.");
}

pub fn critical(&mut self, message: &str)

Log critical-level messages.

Examples

use daemon_console::TerminalApp;

fn main() {
    let mut app = TerminalApp::new();
    app.critical("Application crashed!");
    app.critical("Exception: unknown.");
}

Trait Implementations

impl Default for TerminalApp

fn default() -> Self

Returns the “default value” for a type.