Update client dependencies

[signal-cli] / client / src / main.rs

diff --git a/client/src/main.rs b/client/src/main.rs
index 1ad8dbcfffffafbe21cdec9badac240f0ec5783c..a48584408920e8a835cdd0f8fd4e34c2b9ac7e5e 100644 (file)
--- a/client/src/main.rs
+++ b/client/src/main.rs
@@ -1,68 +1,97 @@
-use clap::StructOpt;
-use jsonrpc_client_transports::{RpcError, TypedSubscriptionStream};
-use jsonrpc_core::{futures_util::StreamExt, Value};

 use std::{path::PathBuf, time::Duration};
 use std::{path::PathBuf, time::Duration};

+
+use clap::Parser;
+use jsonrpsee::core::client::{Error as RpcError, Subscription, SubscriptionClientT};
+use serde_json::Value;

 use tokio::{select, time::sleep};
 
 use tokio::{select, time::sleep};
 

-use crate::cli::{GroupPermission, LinkState};
+use cli::Cli;
+
+use crate::cli::{CliCommands, GroupPermission, LinkState};
+use crate::jsonrpc::RpcClient;

 
 mod cli;
 
 mod cli;

-#[allow(clippy::too_many_arguments)]
+#[allow(non_snake_case, clippy::too_many_arguments)]

 mod jsonrpc;
 mod jsonrpc;

-mod tcp;
+mod transports;

 
 const DEFAULT_TCP: &str = "127.0.0.1:7583";
 const DEFAULT_SOCKET_SUFFIX: &str = "signal-cli/socket";
 
 const DEFAULT_TCP: &str = "127.0.0.1:7583";
 const DEFAULT_SOCKET_SUFFIX: &str = "signal-cli/socket";

+const DEFAULT_HTTP: &str = "http://localhost:8080/api/v1/rpc";

 
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
     let cli = cli::Cli::parse();
 
 
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
     let cli = cli::Cli::parse();
 

-    let client = connect(&cli)
-        .await
-        .map_err(|e| anyhow::anyhow!("Failed to connect to socket: {e}"))?;
+    let result = connect(cli).await;

 
 

-    let result = match cli.command {
-        cli::CliCommands::Receive { timeout } => {
-            let mut stream = client
-                .subscribe_receive(cli.account)
-                .map_err(|e| anyhow::anyhow!("JSON-RPC command failed: {:?}", e))?;
+    match result {
+        Ok(Value::Null) => {}
+        Ok(v) => println!("{v}"),
+        Err(e) => return Err(anyhow::anyhow!("JSON-RPC command failed: {e:?}")),
+    }
+    Ok(())
+}
+
+async fn handle_command(
+    cli: Cli,
+    client: impl SubscriptionClientT + Sync,
+) -> Result<Value, RpcError> {
+    match cli.command {
+        CliCommands::Receive { timeout } => {
+            let mut stream = client.subscribe_receive(cli.account).await?;

 
             {
                 while let Some(v) = stream_next(timeout, &mut stream).await {
 
             {
                 while let Some(v) = stream_next(timeout, &mut stream).await {

-                    let v = v.map_err(|e| anyhow::anyhow!("JSON-RPC command failed: {:?}", e))?;
+                    let v = v?;

                     println!("{v}");
                 }
             }
                     println!("{v}");
                 }
             }

-            return Ok(());
+            stream.unsubscribe().await?;
+            Ok(Value::Null)

         }
         }

-        cli::CliCommands::AddDevice { uri } => client.add_device(cli.account, uri).await,
-        cli::CliCommands::Block {
+        CliCommands::AddDevice { uri } => client.add_device(cli.account, uri).await,
+        CliCommands::Block {

             recipient,
             group_id,
         } => client.block(cli.account, recipient, group_id).await,
             recipient,
             group_id,
         } => client.block(cli.account, recipient, group_id).await,

-        cli::CliCommands::GetUserStatus { recipient } => {
+        CliCommands::DeleteLocalAccountData { ignore_registered } => {
+            client
+                .delete_local_account_data(cli.account, ignore_registered)
+                .await
+        }
+        CliCommands::GetUserStatus { recipient } => {

             client.get_user_status(cli.account, recipient).await
         }
             client.get_user_status(cli.account, recipient).await
         }

-        cli::CliCommands::JoinGroup { uri } => client.join_group(cli.account, uri).await,
-        cli::CliCommands::Link { name } => {
+        CliCommands::JoinGroup { uri } => client.join_group(cli.account, uri).await,
+        CliCommands::Link { name } => {

             let url = client
                 .start_link(cli.account)
                 .await
             let url = client
                 .start_link(cli.account)
                 .await

-                .map_err(|e| anyhow::anyhow!("JSON-RPC command startLink failed: {e:?}",))?
+                .map_err(|e| RpcError::Custom(format!("JSON-RPC command startLink failed: {e:?}")))?

                 .device_link_uri;
             println!("{}", url);
             client.finish_link(url, name).await
         }
                 .device_link_uri;
             println!("{}", url);
             client.finish_link(url, name).await
         }

-        cli::CliCommands::ListAccounts => client.list_accounts().await,
-        cli::CliCommands::ListContacts => client.list_contacts(cli.account).await,
-        cli::CliCommands::ListDevices => client.list_devices(cli.account).await,
-        cli::CliCommands::ListGroups { detailed: _ } => client.list_groups(cli.account).await,
-        cli::CliCommands::ListIdentities { number } => {
-            client.list_identities(cli.account, number).await
+        CliCommands::ListAccounts => client.list_accounts().await,
+        CliCommands::ListContacts {
+            recipient,
+            all_recipients,
+            blocked,
+            name,
+        } => {
+            client
+                .list_contacts(cli.account, recipient, all_recipients, blocked, name)
+                .await

         }
         }

-        cli::CliCommands::ListStickerPacks => client.list_sticker_packs(cli.account).await,
-        cli::CliCommands::QuitGroup {
+        CliCommands::ListDevices => client.list_devices(cli.account).await,
+        CliCommands::ListGroups {
+            detailed: _,
+            group_id,
+        } => client.list_groups(cli.account, group_id).await,
+        CliCommands::ListIdentities { number } => client.list_identities(cli.account, number).await,
+        CliCommands::ListStickerPacks => client.list_sticker_packs(cli.account).await,
+        CliCommands::QuitGroup {

             group_id,
             delete,
             admin,
             group_id,
             delete,
             admin,


@@ -71,17 +100,23 @@ async fn main() -> Result<(), anyhow::Error> {
                 .quit_group(cli.account, group_id, delete, admin)
                 .await
         }
                 .quit_group(cli.account, group_id, delete, admin)
                 .await
         }

-        cli::CliCommands::Register { voice, captcha } => {
+        CliCommands::Register { voice, captcha } => {

             client.register(cli.account, voice, captcha).await
         }
             client.register(cli.account, voice, captcha).await
         }

-        cli::CliCommands::RemoveContact { recipient, forget } => {
-            client.remove_contact(cli.account, recipient, forget).await
+        CliCommands::RemoveContact {
+            recipient,
+            forget,
+            hide,
+        } => {
+            client
+                .remove_contact(cli.account, recipient, forget, hide)
+                .await

         }
         }

-        cli::CliCommands::RemoveDevice { device_id } => {
+        CliCommands::RemoveDevice { device_id } => {

             client.remove_device(cli.account, device_id).await
         }
             client.remove_device(cli.account, device_id).await
         }

-        cli::CliCommands::RemovePin => client.remove_pin(cli.account).await,
-        cli::CliCommands::RemoteDelete {
+        CliCommands::RemovePin => client.remove_pin(cli.account).await,
+        CliCommands::RemoteDelete {

             target_timestamp,
             recipient,
             group_id,
             target_timestamp,
             recipient,
             group_id,


@@ -97,7 +132,7 @@ async fn main() -> Result<(), anyhow::Error> {
                 )
                 .await
         }
                 )
                 .await
         }

-        cli::CliCommands::Send {
+        CliCommands::Send {

             recipient,
             group_id,
             note_to_self,
             recipient,
             group_id,
             note_to_self,


@@ -105,11 +140,21 @@ async fn main() -> Result<(), anyhow::Error> {
             message,
             attachment,
             mention,
             message,
             attachment,
             mention,

+            text_style,

             quote_timestamp,
             quote_author,
             quote_message,
             quote_mention,
             quote_timestamp,
             quote_author,
             quote_message,
             quote_mention,

+            quote_text_style,
+            quote_attachment,
+            preview_url,
+            preview_title,
+            preview_description,
+            preview_image,

             sticker,
             sticker,

+            story_timestamp,
+            story_author,
+            edit_timestamp,

         } => {
             client
                 .send(
         } => {
             client
                 .send(


@@ -121,16 +166,35 @@ async fn main() -> Result<(), anyhow::Error> {
                     message.unwrap_or_default(),
                     attachment,
                     mention,
                     message.unwrap_or_default(),
                     attachment,
                     mention,

+                    text_style,

                     quote_timestamp,
                     quote_author,
                     quote_message,
                     quote_mention,
                     quote_timestamp,
                     quote_author,
                     quote_message,
                     quote_mention,

+                    quote_text_style,
+                    quote_attachment,
+                    preview_url,
+                    preview_title,
+                    preview_description,
+                    preview_image,

                     sticker,
                     sticker,

+                    story_timestamp,
+                    story_author,
+                    edit_timestamp,

                 )
                 .await
         }
                 )
                 .await
         }

-        cli::CliCommands::SendContacts => client.send_contacts(cli.account).await,
-        cli::CliCommands::SendReaction {
+        CliCommands::SendContacts => client.send_contacts(cli.account).await,
+        CliCommands::SendPaymentNotification {
+            recipient,
+            receipt,
+            note,
+        } => {
+            client
+                .send_payment_notification(cli.account, recipient, receipt, note)
+                .await
+        }
+        CliCommands::SendReaction {

             recipient,
             group_id,
             note_to_self,
             recipient,
             group_id,
             note_to_self,


@@ -138,6 +202,7 @@ async fn main() -> Result<(), anyhow::Error> {
             target_author,
             target_timestamp,
             remove,
             target_author,
             target_timestamp,
             remove,

+            story,

         } => {
             client
                 .send_reaction(
         } => {
             client
                 .send_reaction(


@@ -149,10 +214,11 @@ async fn main() -> Result<(), anyhow::Error> {
                     target_author,
                     target_timestamp,
                     remove,
                     target_author,
                     target_timestamp,
                     remove,

+                    story,

                 )
                 .await
         }
                 )
                 .await
         }

-        cli::CliCommands::SendReceipt {
+        CliCommands::SendReceipt {

             recipient,
             target_timestamp,
             r#type,
             recipient,
             target_timestamp,
             r#type,


@@ -169,8 +235,8 @@ async fn main() -> Result<(), anyhow::Error> {
                 )
                 .await
         }
                 )
                 .await
         }

-        cli::CliCommands::SendSyncRequest => client.send_sync_request(cli.account).await,
-        cli::CliCommands::SendTyping {
+        CliCommands::SendSyncRequest => client.send_sync_request(cli.account).await,
+        CliCommands::SendTyping {

             recipient,
             group_id,
             stop,
             recipient,
             group_id,
             stop,


@@ -179,13 +245,13 @@ async fn main() -> Result<(), anyhow::Error> {
                 .send_typing(cli.account, recipient, group_id, stop)
                 .await
         }
                 .send_typing(cli.account, recipient, group_id, stop)
                 .await
         }

-        cli::CliCommands::SetPin { pin } => client.set_pin(cli.account, pin).await,
-        cli::CliCommands::SubmitRateLimitChallenge { challenge, captcha } => {
+        CliCommands::SetPin { pin } => client.set_pin(cli.account, pin).await,
+        CliCommands::SubmitRateLimitChallenge { challenge, captcha } => {

             client
                 .submit_rate_limit_challenge(cli.account, challenge, captcha)
                 .await
         }
             client
                 .submit_rate_limit_challenge(cli.account, challenge, captcha)
                 .await
         }

-        cli::CliCommands::Trust {
+        CliCommands::Trust {

             recipient,
             trust_all_known_keys,
             verified_safety_number,
             recipient,
             trust_all_known_keys,
             verified_safety_number,


@@ -199,17 +265,22 @@ async fn main() -> Result<(), anyhow::Error> {
                 )
                 .await
         }
                 )
                 .await
         }

-        cli::CliCommands::Unblock {
+        CliCommands::Unblock {

             recipient,
             group_id,
         } => client.unblock(cli.account, recipient, group_id).await,
             recipient,
             group_id,
         } => client.unblock(cli.account, recipient, group_id).await,

-        cli::CliCommands::Unregister { delete_account } => {
+        CliCommands::Unregister { delete_account } => {

             client.unregister(cli.account, delete_account).await
         }
             client.unregister(cli.account, delete_account).await
         }

-        cli::CliCommands::UpdateAccount { device_name } => {
-            client.update_account(cli.account, device_name).await
+        CliCommands::UpdateAccount {
+            device_name,
+            unrestricted_unidentified_sender,
+        } => {
+            client
+                .update_account(cli.account, device_name, unrestricted_unidentified_sender)
+                .await

         }
         }

-        cli::CliCommands::UpdateConfiguration {
+        CliCommands::UpdateConfiguration {

             read_receipts,
             unidentified_delivery_indicators,
             typing_indicators,
             read_receipts,
             unidentified_delivery_indicators,
             typing_indicators,


@@ -225,7 +296,7 @@ async fn main() -> Result<(), anyhow::Error> {
                 )
                 .await
         }
                 )
                 .await
         }

-        cli::CliCommands::UpdateContact {
+        CliCommands::UpdateContact {

             recipient,
             expiration,
             name,
             recipient,
             expiration,
             name,


@@ -234,7 +305,7 @@ async fn main() -> Result<(), anyhow::Error> {
                 .update_contact(cli.account, recipient, name, expiration)
                 .await
         }
                 .update_contact(cli.account, recipient, name, expiration)
                 .await
         }

-        cli::CliCommands::UpdateGroup {
+        CliCommands::UpdateGroup {

             group_id,
             name,
             description,
             group_id,
             name,
             description,


@@ -243,6 +314,8 @@ async fn main() -> Result<(), anyhow::Error> {
             remove_member,
             admin,
             remove_admin,
             remove_member,
             admin,
             remove_admin,

+            ban,
+            unban,

             reset_link,
             link,
             set_permission_add_member,
             reset_link,
             link,
             set_permission_add_member,


@@ -261,6 +334,8 @@ async fn main() -> Result<(), anyhow::Error> {
                     remove_member,
                     admin,
                     remove_admin,
                     remove_member,
                     admin,
                     remove_admin,

+                    ban,
+                    unban,

                     reset_link,
                     link.map(|link| match link {
                         LinkState::Enabled => "enabled".to_owned(),
                     reset_link,
                     link.map(|link| match link {
                         LinkState::Enabled => "enabled".to_owned(),


@@ -283,11 +358,12 @@ async fn main() -> Result<(), anyhow::Error> {
                 )
                 .await
         }
                 )
                 .await
         }

-        cli::CliCommands::UpdateProfile {
+        CliCommands::UpdateProfile {

             given_name,
             family_name,
             about,
             about_emoji,
             given_name,
             family_name,
             about,
             about_emoji,

+            mobile_coin_address,

             avatar,
             remove_avatar,
         } => {
             avatar,
             remove_avatar,
         } => {


@@ -298,31 +374,70 @@ async fn main() -> Result<(), anyhow::Error> {
                     family_name,
                     about,
                     about_emoji,
                     family_name,
                     about,
                     about_emoji,

+                    mobile_coin_address,

                     avatar,
                     remove_avatar,
                 )
                 .await
         }
                     avatar,
                     remove_avatar,
                 )
                 .await
         }

-        cli::CliCommands::UploadStickerPack { path } => {
+        CliCommands::UploadStickerPack { path } => {

             client.upload_sticker_pack(cli.account, path).await
         }
             client.upload_sticker_pack(cli.account, path).await
         }

-        cli::CliCommands::Verify {
+        CliCommands::Verify {

             verification_code,
             pin,
         } => client.verify(cli.account, verification_code, pin).await,
             verification_code,
             pin,
         } => client.verify(cli.account, verification_code, pin).await,

-        cli::CliCommands::Version => client.version().await,
-    };
-
-    result
-        .map(|v| println!("{v}"))
-        .map_err(|e| anyhow::anyhow!("JSON-RPC command failed: {e:?}",))?;
-    Ok(())
+        CliCommands::Version => client.version().await,
+        CliCommands::AddStickerPack { uri } => client.add_sticker_pack(cli.account, uri).await,
+        CliCommands::FinishChangeNumber {
+            number,
+            verification_code,
+            pin,
+        } => {
+            client
+                .finish_change_number(cli.account, number, verification_code, pin)
+                .await
+        }
+        CliCommands::GetAttachment {
+            id,
+            recipient,
+            group_id,
+        } => {
+            client
+                .get_attachment(cli.account, id, recipient, group_id)
+                .await
+        }
+        CliCommands::StartChangeNumber {
+            number,
+            voice,
+            captcha,
+        } => {
+            client
+                .start_change_number(cli.account, number, voice, captcha)
+                .await
+        }
+    }

 }
 
 }
 

-async fn connect(cli: &cli::Cli) -> Result<jsonrpc::SignalCliClient, RpcError> {
-    if let Some(tcp) = cli.json_rpc_tcp {
+async fn connect(cli: Cli) -> Result<Value, RpcError> {
+    if let Some(http) = &cli.json_rpc_http {
+        let uri = if let Some(uri) = http {
+            uri
+        } else {
+            DEFAULT_HTTP
+        };
+        let client = jsonrpc::connect_http(uri)
+            .await
+            .map_err(|e| RpcError::Custom(format!("Failed to connect to socket: {e}")))?;
+
+        handle_command(cli, client).await
+    } else if let Some(tcp) = cli.json_rpc_tcp {

         let socket_addr = tcp.unwrap_or_else(|| DEFAULT_TCP.parse().unwrap());
         let socket_addr = tcp.unwrap_or_else(|| DEFAULT_TCP.parse().unwrap());

-        jsonrpc::connect_tcp(socket_addr).await
+        let client = jsonrpc::connect_tcp(socket_addr)
+            .await
+            .map_err(|e| RpcError::Custom(format!("Failed to connect to socket: {e}")))?;
+
+        handle_command(cli, client).await

     } else {
         let socket_path = cli
             .json_rpc_socket
     } else {
         let socket_path = cli
             .json_rpc_socket


@@ -336,13 +451,17 @@ async fn connect(cli: &cli::Cli) -> Result<jsonrpc::SignalCliClient, RpcError> {
                 })
             })
             .unwrap_or_else(|| ("/run".to_owned() + DEFAULT_SOCKET_SUFFIX).into());
                 })
             })
             .unwrap_or_else(|| ("/run".to_owned() + DEFAULT_SOCKET_SUFFIX).into());

-        jsonrpc::connect_unix(socket_path).await
+        let client = jsonrpc::connect_unix(socket_path)
+            .await
+            .map_err(|e| RpcError::Custom(format!("Failed to connect to socket: {e}")))?;
+
+        handle_command(cli, client).await

     }
 }
 
 async fn stream_next(
     timeout: f64,
     }
 }
 
 async fn stream_next(
     timeout: f64,

-    stream: &mut TypedSubscriptionStream<Value>,
+    stream: &mut Subscription<Value>,

 ) -> Option<Result<Value, RpcError>> {
     if timeout < 0.0 {
         stream.next().await
 ) -> Option<Result<Value, RpcError>> {
     if timeout < 0.0 {
         stream.next().await