1 files changed, 34 insertions, 15 deletions

diff --git a/mumctl/src/main.rs b/mumctl/src/main.rs
index bf1ffdc..5b2bc05 100644
--- a/mumctl/src/main.rs
+++ b/mumctl/src/main.rs
@@ -1,6 +1,6 @@
 use colored::Colorize;
 use log::*;
-use mumlib::command::{Command as MumCommand, CommandResponse, MessageTarget};
+use mumlib::command::{ChannelTarget, Command as MumCommand, CommandResponse, MessageTarget};
 use mumlib::config::{self, Config, ServerConfig};
 use mumlib::state::Channel as MumChannel;
 use serde::de::DeserializeOwned;
@@ -89,6 +89,11 @@ enum Command {
     },
     /// Send a message to a channel or a user
     Message(Target),
+    /// Get events that have happened since we connected
+    Events {
+        #[structopt(short = "f", long = "follow")]
+        follow: bool,
+    },
 }
 
 #[derive(Debug, StructOpt)]
@@ -96,10 +101,10 @@ enum Target {
     Channel {
         /// The message to send
         message: String,
-        /// If the message should be sent recursivley to sub-channels
+        /// If the message should be sent recursively to sub-channels
         #[structopt(short = "r", long = "recursive")]
         recursive: bool,
-        /// Which channels to send to
+        /// Which channels to send to. Defaults to current channel if left empty
         names: Vec<String>,
     },
     User {
@@ -274,10 +279,10 @@ fn match_opt() -> Result<(), Error> {
                 accept_invalid_cert: cli_accept_invalid_cert || config_accept_invalid_cert.unwrap_or(false),
             })?;
             match response {
-                Ok(Some(CommandResponse::ServerConnect { welcome_message })) => {
-                    println!("Connected to {}", host);
+                Ok(Some(CommandResponse::ServerConnect { welcome_message , server_state })) => {
+                    parse_state(&server_state);
                     if let Some(message) = welcome_message {
-                        println!("Welcome: {}", message);
+                        println!("\nWelcome: {}", message);
                     }
                 }
                 Err(mumlib::error::Error::ServerCertReject) => {
@@ -394,7 +399,7 @@ fn match_opt() -> Result<(), Error> {
             for response in send_command_multi(MumCommand::PastMessages { block: follow })? {
                 match response {
                     Ok(Some(CommandResponse::PastMessage { message })) => {
-                        println!("{}: {}", message.1, message.0)
+                        println!("[{}] {}: {}", message.0.format("%d %b %H:%M"), message.2, message.1)
                     }
                     Ok(_) => unreachable!("Response should only be a Some(PastMessages)"),
                     Err(e) => error!("{}", e),
@@ -409,24 +414,38 @@ fn match_opt() -> Result<(), Error> {
             } => {
                 let msg = MumCommand::SendMessage {
                     message,
-                    targets: names
-                        .into_iter()
-                        .map(|name| MessageTarget::Channel { name, recursive })
-                        .collect(),
+                    targets: if names.is_empty() {
+                        MessageTarget::Channel(vec![(ChannelTarget::Current, recursive)])
+                    } else {
+                        MessageTarget::Channel(
+                            names
+                                .into_iter()
+                                .map(|name| (ChannelTarget::Named(name), recursive))
+                                .collect()
+                        )
+                    },
                 };
                 send_command(msg)??;
             }
             Target::User { message, names } => {
                 let msg = MumCommand::SendMessage {
                     message,
-                    targets: names
-                        .into_iter()
-                        .map(|name| MessageTarget::User { name })
-                        .collect(),
+                    targets: MessageTarget::User(names),
                 };
                 send_command(msg)??;
             }
         },
+        Command::Events { follow } => {
+            for response in send_command_multi(MumCommand::Events { block: follow })? {
+                match response {
+                    Ok(Some(CommandResponse::Event { event })) => {
+                        println!("{}", event)
+                    }
+                    Ok(_) => unreachable!("Response should only be a Some(Event)"),
+                    Err(e) => error!("{}", e),
+                }
+            }
+        }
     }
 
     let config_path = config::default_cfg_path();