svix-cli: add interactive login

Author: svix-lucho

svix-cli/Cargo.toml

@@ -43,7 +43,7 @@ idna_adapter = "=1.1.0"
 indoc = "2.0.5"
 open = "5.3.1"
 rand = "0.8.5"
-reqwest = { version = "0.12.9", features = ["rustls-tls", "charset", "http2", "macos-system-configuration"], default-features = false }
+reqwest = { version = "0.12.9", features = ["rustls-tls", "json", "charset", "http2", "macos-system-configuration"], default-features = false }
 serde = { version = "1.0.215", features = ["derive"] }
 serde_json = "1.0.133"
 svix = { path = "../rust" }

svix-cli/src/cmds/login.rs

@@ -1,25 +1,40 @@
-use anyhow::Result;
+use std::time::{Duration, Instant};
+
+use anyhow::{Context, Result};
 use dialoguer::Input;
+use reqwest::Client;
+use serde::Deserialize;
 
 use crate::{config, config::Config};
 
-pub fn prompt() -> Result<()> {
+pub async fn prompt(_cfg: &Config) -> Result<()> {
     print!("Welcome to the Svix CLI!\n\n");
 
-    let auth_token = Input::new()
-        .with_prompt("Auth Token")
-        .validate_with({
-            move |input: &String| -> Result<()> {
-                if !input.trim().is_empty() {
-                    Ok(())
-                } else {
-                    Err(anyhow::anyhow!("auth token cannot be empty"))
+    let selections = &["Login in dashboard.svix.com", "Input token manually"];
+    let selection = dialoguer::Select::new()
+        .with_prompt("How would you like to authenticate?")
+        .items(selections)
+        .default(0)
+        .interact()?;
+
+    let auth_token = if selection == 0 {
+        dashboard_login().await?
+    } else {
+        Input::new()
+            .with_prompt("Auth Token")
+            .validate_with({
+                move |input: &String| -> Result<()> {
+                    if !input.trim().is_empty() {
+                        Ok(())
+                    } else {
+                        Err(anyhow::anyhow!("auth token cannot be empty"))
+                    }
                 }
-            }
-        })
-        .interact_text()?
-        .trim()
-        .to_string();
+            })
+            .interact_text()?
+            .trim()
+            .to_string()
+    };
 
     // Load from disk and update the prompted fields.
     // There are other fields (not prompted for) related to "relay" for the `listen` command
@@ -45,3 +60,108 @@ pub fn prompt() -> Result<()> {
     );
     Ok(())
 }
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct CliStartLoginSessionOut {
+    session_id: String,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AuthTokenOut {
+    token: String,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DiscoverySessionOut {
+    pub region: String,
+}
+
+const DASHBOARD_URL: &str = "https://dashboard.svix.com";
+const LOGIN_SERVER_URL: &str = "https://api.svix.com";
+
+pub async fn dashboard_login() -> Result<String> {
+    let client = reqwest::Client::new();
+
+    let start_session = client
+        .post(format!("{LOGIN_SERVER_URL}/dashboard/cli/login/start"))
+        .send()
+        .await
+        .context("Failed to get session ID. Could not connect to server.")?
+        .json::<CliStartLoginSessionOut>()
+        .await
+        .context("Failed to get session ID. Invalid response.")?;
+
+    let session_id = start_session.session_id;
+    let code = &session_id[0..4].to_uppercase();
+
+    let url = format!("{DASHBOARD_URL}/cli/login?sessionId={session_id}&code={code}");
+
+    println!("\nPlease approve the login in your browser, then return here.");
+    println!("Verification code: \x1b[32m{}\x1b[0m\n", code);
+
+    if let Err(e) = open::that(&url) {
+        eprintln!("Failed to open browser: {}", e);
+        println!("Please manually open this URL in your browser: {}", url);
+    }
+
+    println!("Waiting for approval...");
+
+    // First, poll the discovery endpoint to get the region
+    let discovery_poll_url = format!("{LOGIN_SERVER_URL}/dashboard/cli/login/discovery/complete");
+    let discovery_data: DiscoverySessionOut =
+        poll_session(&client, &discovery_poll_url, &session_id).await?;
+
+    let region = discovery_data.region;
+    let region_server_url = format!("https://api.{region}.svix.com");
+    let token_poll_url = format!("{region_server_url}/dashboard/cli/login/token/complete");
+
+    // Then, poll the token endpoint to get the auth token
+    let token_data: AuthTokenOut = poll_session(&client, &token_poll_url, &session_id).await?;
+
+    println!("Authentication successful!\n");
+    Ok(token_data.token)
+}
+
+const MAX_POLL_TIME: Duration = Duration::from_secs(5 * 60);
+
+async fn poll_session<T>(client: &Client, poll_url: &str, session_id: &str) -> Result<T>
+where
+    T: for<'de> serde::Deserialize<'de>,
+{
+    let start_time: Instant = Instant::now();
+
+    while start_time.elapsed() < MAX_POLL_TIME {
+        let response = client
+            .post(poll_url)
+            .json(&serde_json::json!({ "sessionId": session_id }))
+            .send()
+            .await
+            .context("Failed to connect to authentication server")?;
+
+        if response.status().is_success() {
+            return response
+                .json::<T>()
+                .await
+                .context("Failed to parse authentication data");
+        } else if response.status() != reqwest::StatusCode::NOT_FOUND {
+            // Bail if session exists but has an error (is expired or something else)
+            let error_message = match response.json::<serde_json::Value>().await {
+                Ok(json) => json
+                    .get("detail")
+                    .and_then(|d| d.as_str())
+                    .unwrap_or("Unknown error")
+                    .to_string(),
+                Err(_) => "Unknown error".to_string(),
+            };
+
+            anyhow::bail!("Authentication failed: {error_message}");
+        }
+
+        std::thread::sleep(std::time::Duration::from_secs(1));
+    }
+
+    anyhow::bail!("Authentication failed.");
+}

svix-cli/src/main.rs

@@ -164,7 +164,7 @@ async fn main() -> Result<()> {
         }
 
         RootCommands::Listen(args) => args.exec(&cfg?).await?,
-        RootCommands::Login => cmds::login::prompt()?,
+        RootCommands::Login => cmds::login::prompt(&cfg?).await?,
         RootCommands::Completion { shell } => cmds::completion::generate(&shell)?,
     }