feat: add print command that outputs to logging system

Author: cablehead

README.md

@@ -326,6 +326,9 @@ $ http-nu --log-format jsonl :3001 '{|req| "hello"}'
 
 Lifecycle events: `started`, `reloaded`, `stopping`, `stopped`, `stop_timed_out`
 
+The `print` command outputs to the logging system (appears as `message: "print"`
+in JSONL).
+
 ### Trusted Proxies
 
 When behind a reverse proxy, use `--trust-proxy` to extract client IP from

src/commands.rs

@@ -1,3 +1,4 @@
+use crate::logging::log_print;
 use crate::response::{Response, ResponseBodyType};
 use nu_engine::command_prelude::*;
 use nu_protocol::{
@@ -1433,3 +1434,117 @@ impl Command for MdCommand {
         .into_pipeline_data())
     }
 }
+
+// === .print command ===
+
+#[derive(Clone)]
+pub struct PrintCommand;
+
+impl Default for PrintCommand {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl PrintCommand {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Command for PrintCommand {
+    fn name(&self) -> &str {
+        "print"
+    }
+
+    fn description(&self) -> &str {
+        "Print the given values to the http-nu logging system."
+    }
+
+    fn extra_description(&self) -> &str {
+        r#"This command outputs to http-nu's logging system rather than stdout/stderr.
+Messages appear in both human-readable and JSONL output modes.
+
+`print` may be used inside blocks of code (e.g.: hooks) to display text during execution without interfering with the pipeline."#
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["display"]
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("print")
+            .input_output_types(vec![
+                (Type::Nothing, Type::Nothing),
+                (Type::Any, Type::Nothing),
+            ])
+            .allow_variants_without_examples(true)
+            .rest("rest", SyntaxShape::Any, "the values to print")
+            .switch(
+                "no-newline",
+                "print without inserting a newline for the line ending",
+                Some('n'),
+            )
+            .switch("stderr", "print to stderr instead of stdout", Some('e'))
+            .switch(
+                "raw",
+                "print without formatting (including binary data)",
+                Some('r'),
+            )
+            .category(Category::Strings)
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let args: Vec<Value> = call.rest(engine_state, stack, 0)?;
+        let no_newline = call.has_flag(engine_state, stack, "no-newline")?;
+        let config = stack.get_config(engine_state);
+
+        let format_value = |val: &Value| -> String { val.to_expanded_string(" ", &config) };
+
+        if !args.is_empty() {
+            let messages: Vec<String> = args.iter().map(format_value).collect();
+            let message = if no_newline {
+                messages.join("")
+            } else {
+                messages.join("\n")
+            };
+            log_print(&message);
+        } else if !input.is_nothing() {
+            let message = match input {
+                PipelineData::Value(val, _) => format_value(&val),
+                PipelineData::ListStream(stream, _) => {
+                    let vals: Vec<String> = stream.into_iter().map(|v| format_value(&v)).collect();
+                    vals.join("\n")
+                }
+                PipelineData::ByteStream(stream, _) => stream.into_string()?,
+                PipelineData::Empty => String::new(),
+            };
+            if !message.is_empty() {
+                log_print(&message);
+            }
+        }
+
+        Ok(PipelineData::empty())
+    }
+
+    fn examples(&self) -> Vec<Example<'_>> {
+        vec![
+            Example {
+                description: "Print 'hello world'",
+                example: r#"print "hello world""#,
+                result: None,
+            },
+            Example {
+                description: "Print the sum of 2 and 3",
+                example: r#"print (2 + 3)"#,
+                result: None,
+            },
+        ]
+    }
+}

src/engine.rs

@@ -18,8 +18,8 @@ use nu_protocol::{
 
 use crate::commands::{
     HighlightCommand, HighlightLangCommand, HighlightThemeCommand, MdCommand, MjCommand,
-    MjCompileCommand, MjRenderCommand, ResponseStartCommand, ReverseProxyCommand, StaticCommand,
-    ToSse,
+    MjCompileCommand, MjRenderCommand, PrintCommand, ResponseStartCommand, ReverseProxyCommand,
+    StaticCommand, ToSse,
 };
 use crate::logging::log_error;
 use crate::stdlib::load_http_nu_stdlib;
@@ -302,6 +302,7 @@ impl Engine {
             Box::new(HighlightThemeCommand::new()),
             Box::new(HighlightLangCommand::new()),
             Box::new(MdCommand::new()),
+            Box::new(PrintCommand::new()),
         ])
     }
 

src/logging.rs

@@ -112,11 +112,15 @@ pub enum Event {
     Error {
         error: String,
     },
+    Print {
+        message: String,
+    },
     Stopping {
         inflight: usize,
     },
     Stopped,
     StopTimedOut,
+    Shutdown,
 }
 
 // --- Broadcast channel ---
@@ -192,6 +196,12 @@ pub fn log_error(error: &str) {
     });
 }
 
+pub fn log_print(message: &str) {
+    emit(Event::Print {
+        message: message.to_string(),
+    });
+}
+
 pub fn log_stopping(inflight: usize) {
     emit(Event::Stopping { inflight });
 }
@@ -204,9 +214,13 @@ pub fn log_stop_timed_out() {
     emit(Event::StopTimedOut);
 }
 
+pub fn shutdown() {
+    emit(Event::Shutdown);
+}
+
 // --- JSONL handler (dedicated writer thread does serialization + IO) ---
 
-pub fn run_jsonl_handler(rx: broadcast::Receiver<Event>) {
+pub fn run_jsonl_handler(rx: broadcast::Receiver<Event>) -> std::thread::JoinHandle<()> {
     use std::io::Write;
 
     std::thread::spawn(move || {
@@ -231,13 +245,19 @@ pub fn run_jsonl_handler(rx: broadcast::Receiver<Event>) {
                 Err(broadcast::error::RecvError::Closed) => break,
             };
 
+            if matches!(event, Event::Shutdown) {
+                let _ = stdout.flush();
+                break;
+            }
+
             let needs_flush = matches!(
                 &event,
                 Event::Started { .. }
                     | Event::Stopped
                     | Event::StopTimedOut
                     | Event::Reloaded
                     | Event::Error { .. }
+                    | Event::Print { .. }
             );
 
             let stamp = scru128::new().to_string();
@@ -309,6 +329,13 @@ pub fn run_jsonl_handler(rx: broadcast::Receiver<Event>) {
                         "error": error,
                     })
                 }
+                Event::Print { message } => {
+                    serde_json::json!({
+                        "stamp": stamp,
+                        "message": "print",
+                        "content": message,
+                    })
+                }
                 Event::Stopping { inflight } => {
                     serde_json::json!({
                         "stamp": stamp,
@@ -328,6 +355,7 @@ pub fn run_jsonl_handler(rx: broadcast::Receiver<Event>) {
                         "message": "stop_timed_out",
                     })
                 }
+                Event::Shutdown => unreachable!(),
             };
 
             if let Ok(line) = serde_json::to_string(&json) {
@@ -341,7 +369,7 @@ pub fn run_jsonl_handler(rx: broadcast::Receiver<Event>) {
         }
 
         let _ = stdout.flush();
-    });
+    })
 }
 
 // --- Human-readable handler (dedicated thread) ---
@@ -445,7 +473,7 @@ fn format_complete_line(state: &RequestState, duration_ms: u64, bytes: u64) -> S
     )
 }
 
-pub fn run_human_handler(rx: broadcast::Receiver<Event>) {
+pub fn run_human_handler(rx: broadcast::Receiver<Event>) -> std::thread::JoinHandle<()> {
     std::thread::spawn(move || {
         let mut rx = rx;
         let mut zone = ActiveZone::new();
@@ -498,6 +526,10 @@ pub fn run_human_handler(rx: broadcast::Receiver<Event>) {
                     eprintln!("ERROR: {error}");
                     zone.redraw(&active_ids, &requests);
                 }
+                Event::Print { message } => {
+                    zone.print_permanent(&format!("PRINT: {message}"));
+                    zone.redraw(&active_ids, &requests);
+                }
                 Event::Stopping { inflight } => {
                     zone.print_permanent(&format!(
                         "stopping, {inflight} connection(s) in flight..."
@@ -567,6 +599,7 @@ pub fn run_human_handler(rx: broadcast::Receiver<Event>) {
                         zone.redraw(&active_ids, &requests);
                     }
                 }
+                Event::Shutdown => break,
             }
         }
 
@@ -578,7 +611,7 @@ pub fn run_human_handler(rx: broadcast::Receiver<Event>) {
         if lagged > 0 {
             println!("⚠ total lagged: {lagged} events dropped");
         }
-    });
+    })
 }
 
 // --- RequestGuard: ensures Complete fires even on abort ---

src/main.rs

@@ -14,7 +14,7 @@ use http_nu::{
     listener::TlsConfig,
     logging::{
         init_broadcast, log_reloaded, log_started, log_stop_timed_out, log_stopped, log_stopping,
-        run_human_handler, run_jsonl_handler,
+        run_human_handler, run_jsonl_handler, shutdown,
     },
     Engine, Listener,
 };
@@ -457,10 +457,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
     // Set up logging handler based on log format (both spawn dedicated threads)
     let rx = init_broadcast();
-    match args.log_format {
+    let log_handle = match args.log_format {
         LogFormat::Human => run_human_handler(rx),
         LogFormat::Jsonl => run_jsonl_handler(rx),
-    }
+    };
 
     rustls::crypto::aws_lc_rs::default_provider()
         .install_default()
@@ -505,16 +505,22 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
         engine.set_signals(interrupt.clone());
 
-        match engine.eval(&script) {
+        let exit_code = match engine.eval(&script) {
             Ok(value) => {
-                println!("{}", value.to_expanded_string(" ", &engine.state.config));
-                return Ok(());
+                let output = value.to_expanded_string(" ", &engine.state.config);
+                if !output.is_empty() {
+                    println!("{output}");
+                }
+                0
             }
             Err(e) => {
                 eprintln!("{e}");
-                std::process::exit(1);
+                1
             }
-        }
+        };
+        shutdown();
+        log_handle.join().ok();
+        std::process::exit(exit_code);
     }
 
     // Server mode (default)
@@ -643,5 +649,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
         args.trust_proxies,
         std::time::Instant::now(),
     )
-    .await
+    .await?;
+
+    shutdown();
+    log_handle.join().ok();
+    Ok(())
 }

src/test_handler.rs

@@ -6,7 +6,7 @@ use http_body_util::{BodyExt, Empty, Full};
 use hyper::{body::Bytes, Request};
 use tokio::time::Duration;
 
-use crate::commands::{MjCommand, ResponseStartCommand, StaticCommand, ToSse};
+use crate::commands::{MjCommand, PrintCommand, ResponseStartCommand, StaticCommand, ToSse};
 use crate::handler::handle;
 
 fn no_trusted_proxies() -> Arc<Vec<ipnet::IpNet>> {
@@ -323,6 +323,7 @@ fn test_engine(script: &str) -> crate::Engine {
             Box::new(StaticCommand::new()),
             Box::new(ToSse {}),
             Box::new(MjCommand::new()),
+            Box::new(PrintCommand::new()),
         ])
         .unwrap();
     engine.parse_closure(script).unwrap();

tests/eval_test.rs

@@ -61,6 +61,17 @@ fn test_eval_mj_compile_and_render() {
         .stdout("Hi World\n");
 }
 
+#[test]
+fn test_eval_print() {
+    Command::cargo_bin("http-nu")
+        .unwrap()
+        .args(["--log-format", "jsonl", "eval", "-c", r#"print "hello""#])
+        .assert()
+        .success()
+        .stdout(predicates::str::contains(r#""message":"print""#))
+        .stdout(predicates::str::contains(r#""content":"hello""#));
+}
+
 #[test]
 fn test_eval_syntax_error() {
     Command::cargo_bin("http-nu")