Add derive-based protocol leaf declarations

examples/protocol_remote_shell_receive.rs

@@ -0,0 +1,73 @@
+#[path = "support/protocol_remote_shell_common.rs"]
+mod common;
+
+use std::error::Error;
+use std::net::TcpListener;
+
+use unshell::protocol::tree::{Endpoint, Ingress, LocalEvent};
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let listener = TcpListener::bind(common::LISTEN_ADDR)?;
+    println!("listening on {}", common::LISTEN_ADDR);
+
+    let (mut stream, peer_addr) = listener.accept()?;
+    println!("accepted endpoint connection from {peer_addr}");
+
+    let frame_rx = common::spawn_frame_reader(stream.try_clone()?);
+    let mut endpoint = common::build_controller_endpoint();
+    let hook_id = endpoint.allocate_hook_id();
+    let shell_leaf_name = common::shell_leaf_name();
+    let start_procedure = common::shell_start_procedure();
+
+    let outcome = endpoint.send_call(
+        common::agent_path(),
+        Some(shell_leaf_name),
+        start_procedure.clone(),
+        Some(hook_id),
+        Vec::new(),
+    )?;
+    let _ = common::pump_outcome(&mut stream, outcome)?;
+
+    let mut commands_sent = false;
+
+    for result in frame_rx {
+        let frame = result?;
+        let outcome = endpoint.receive(&Ingress::Child(common::agent_path()), frame)?;
+        let event = common::pump_outcome(&mut stream, outcome)?;
+
+        let Some(event) = event else {
+            continue;
+        };
+
+        match event {
+            LocalEvent::Data { message, .. } => {
+                print!("{}", String::from_utf8_lossy(&message.data));
+
+                if !commands_sent {
+                    commands_sent = true;
+                    for (index, command) in ["pwd\n", "whoami\n", "exit\n"].iter().enumerate() {
+                        let outcome = endpoint.send_data(
+                            common::agent_path(),
+                            hook_id,
+                            start_procedure.clone(),
+                            command.as_bytes().to_vec(),
+                            index == 2,
+                        )?;
+                        let _ = common::pump_outcome(&mut stream, outcome)?;
+                    }
+                }
+
+                if message.end_hook {
+                    break;
+                }
+            }
+            LocalEvent::Fault { message, .. } => {
+                eprintln!("received protocol fault: 0x{:02X}", message.fault.0);
+                break;
+            }
+            LocalEvent::Call { .. } => {}
+        }
+    }
+
+    Ok(())
+}