feat: add auth command to CLI for authentication management (#98)

* feat: add `auth` command to CLI for authentication management and introduce new monitoring and testing scripts.

* feat: Add `nblm.login()` Python function and `drive_access` option to CLI and Python authentication, along with new test and monitoring scripts.

* feat: implement special command parsing for 'doctor' and 'auth' in CLI

- Added `SpecialCommand` enum to handle specific commands bypassing the main CLI initialization.
- Introduced `parse_pre_command` function to parse command-line arguments for 'doctor' and 'auth' commands.
- Refactored the main function to utilize the new command parsing logic, improving command handling.
- Added unit tests for `parse_pre_command` to ensure correct behavior for different command scenarios.
- Created a `build_login_command` function in the auth module to streamline command construction for authentication.\

* chore: bump package versions to 0.2.3 for nblm-cli, nblm-core, nblm-python, and related Python project files

Author: K-dash

crates/nblm-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nblm-cli"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 license = "MIT"
 description = "Command-line interface for NotebookLM Enterprise API"
@@ -28,7 +28,7 @@ tracing-subscriber = { version = "0.3.20", features = [
     "fmt",
     "json",
 ] }
-nblm-core = { version = "0.2.2", path = "../nblm-core" }
+nblm-core = { version = "0.2.3", path = "../nblm-core" }
 humantime = "2.3.0"
 url = "2.5.7"
 mime_guess = "2.0.5"

crates/nblm-cli/src/app.rs

@@ -70,6 +70,7 @@ impl NblmApp {
             Command::Notebooks(cmd) => notebooks::run(cmd, &client, json_mode).await,
             Command::Sources(cmd) => sources::run(cmd, &client, json_mode).await,
             Command::Audio(cmd) => audio::run(cmd, &client, json_mode).await,
+            Command::Auth(cmd) => crate::ops::auth::run(cmd).await,
             Command::Doctor(cmd) => doctor::run(cmd).await,
         }
     }

crates/nblm-cli/src/args.rs

@@ -70,9 +70,32 @@ pub enum Command {
     Sources(ops::sources::Command),
     #[command(subcommand)]
     Audio(ops::audio::Command),
+    /// Manage authentication using Google Cloud SDK (gcloud)
+    Auth(AuthCommand),
     Doctor(ops::doctor::DoctorArgs),
 }
 
+#[derive(Args)]
+pub struct AuthCommand {
+    #[command(subcommand)]
+    pub command: AuthSubcommand,
+}
+
+#[derive(Subcommand)]
+pub enum AuthSubcommand {
+    /// Log in via Google Cloud SDK (gcloud auth login)
+    Login(LoginArgs),
+    /// Check current authentication status
+    Status,
+}
+
+#[derive(Args)]
+pub struct LoginArgs {
+    /// Request Google Drive access (adds --enable-gdrive-access to gcloud)
+    #[arg(long)]
+    pub drive_access: bool,
+}
+
 #[derive(Copy, Clone, ValueEnum)]
 pub enum AuthMethod {
     Gcloud,
@@ -113,3 +136,122 @@ impl From<ProfileArg> for ApiProfile {
         }
     }
 }
+
+pub enum SpecialCommand {
+    Doctor(crate::ops::doctor::DoctorArgs),
+    Auth(AuthCommand),
+}
+
+pub fn parse_pre_command(args: &[String]) -> Option<SpecialCommand> {
+    if args.len() <= 1 {
+        return None;
+    }
+
+    match args[1].as_str() {
+        "doctor" => {
+            #[derive(Parser)]
+            #[command(name = "nblm")]
+            struct DoctorCli {
+                #[command(subcommand)]
+                command: DoctorCommand,
+            }
+
+            #[derive(Subcommand)]
+            enum DoctorCommand {
+                Doctor(crate::ops::doctor::DoctorArgs),
+            }
+
+            // We use try_parse_from to avoid exiting the process on error/help
+            // But for main logic we might want to just parse.
+            // Here we are replicating main.rs logic which assumes if "doctor" is present
+            // we treat it as doctor command.
+            // However, main.rs used `parse()` which exits.
+            // To keep it testable, we should probably use `try_parse_from`.
+            // But `main.rs` logic was: if args[1] == "doctor", parse as DoctorCli.
+
+            // If parsing fails (e.g. --help), we might want to let main handle it or return None?
+            // In main.rs, it called `parse()`, so it would exit.
+            // For exact behavior preservation:
+            let cli = DoctorCli::parse_from(args);
+            let DoctorCommand::Doctor(args) = cli.command;
+            Some(SpecialCommand::Doctor(args))
+        }
+        "auth" => {
+            #[derive(Parser)]
+            #[command(name = "nblm")]
+            struct AuthCli {
+                #[command(subcommand)]
+                command: AuthCommandWrapper,
+            }
+
+            #[derive(Subcommand)]
+            enum AuthCommandWrapper {
+                Auth(AuthCommand),
+            }
+
+            let cli = AuthCli::parse_from(args);
+            let AuthCommandWrapper::Auth(cmd) = cli.command;
+            Some(SpecialCommand::Auth(cmd))
+        }
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_pre_command() {
+        // Test doctor
+        let args = vec!["nblm".to_string(), "doctor".to_string()];
+        match parse_pre_command(&args) {
+            Some(SpecialCommand::Doctor(_)) => {}
+            _ => panic!("expected Doctor command"),
+        }
+
+        // Test auth
+        let args = vec!["nblm".to_string(), "auth".to_string(), "login".to_string()];
+        match parse_pre_command(&args) {
+            Some(SpecialCommand::Auth(cmd)) => match cmd.command {
+                AuthSubcommand::Login(_) => {}
+                _ => panic!("expected Login subcommand"),
+            },
+            _ => panic!("expected Auth command"),
+        }
+
+        // Test normal command
+        let args = vec!["nblm".to_string(), "notebooks".to_string()];
+        assert!(parse_pre_command(&args).is_none());
+    }
+
+    #[test]
+    fn parse_auth_command() {
+        let args = Cli::parse_from(["nblm", "auth", "login"]);
+        match args.command {
+            Command::Auth(cmd) => match cmd.command {
+                AuthSubcommand::Login(_) => {}
+                _ => panic!("expected Login subcommand"),
+            },
+            _ => panic!("expected Auth command"),
+        }
+
+        let args = Cli::parse_from(["nblm", "auth", "login", "--drive-access"]);
+        match args.command {
+            Command::Auth(cmd) => match cmd.command {
+                AuthSubcommand::Login(args) => assert!(args.drive_access),
+                _ => panic!("expected Login subcommand"),
+            },
+            _ => panic!("expected Auth command"),
+        }
+
+        let args = Cli::parse_from(["nblm", "auth", "status"]);
+        match args.command {
+            Command::Auth(cmd) => match cmd.command {
+                AuthSubcommand::Status => {}
+                _ => panic!("expected Status subcommand"),
+            },
+            _ => panic!("expected Auth command"),
+        }
+    }
+}

crates/nblm-cli/src/main.rs

@@ -18,24 +18,12 @@ async fn main() -> Result<()> {
         anyhow::bail!("The --json flag is not supported for the 'doctor' command");
     }
 
-    if args.len() > 1 && args[1] == "doctor" {
-        // Parse doctor-specific arguments
-        use clap::Parser;
-        #[derive(Parser)]
-        #[command(name = "nblm")]
-        struct DoctorCli {
-            #[command(subcommand)]
-            command: DoctorCommand,
+    // Check for special commands that need to bypass NblmApp initialization
+    if let Some(cmd) = args::parse_pre_command(&args) {
+        match cmd {
+            args::SpecialCommand::Doctor(args) => return ops::doctor::run(args).await,
+            args::SpecialCommand::Auth(cmd) => return ops::auth::run(cmd).await,
         }
-
-        #[derive(clap::Subcommand)]
-        enum DoctorCommand {
-            Doctor(ops::doctor::DoctorArgs),
-        }
-
-        let doctor_cli = DoctorCli::parse();
-        let DoctorCommand::Doctor(doctor_args) = doctor_cli.command;
-        return ops::doctor::run(doctor_args).await;
     }
 
     let cli = args::Cli::parse();

crates/nblm-cli/src/ops/auth.rs

@@ -0,0 +1,119 @@
+use anyhow::{Context, Result};
+use colored::Colorize;
+use std::process::Stdio;
+use tokio::process::Command;
+
+use crate::args::{AuthCommand, AuthSubcommand};
+
+pub async fn run(cmd: AuthCommand) -> Result<()> {
+    match cmd.command {
+        AuthSubcommand::Login(args) => login(args).await,
+        AuthSubcommand::Status => status().await,
+    }
+}
+
+async fn login(args: crate::args::LoginArgs) -> Result<()> {
+    println!("{}", "Starting Google Cloud authentication...".cyan());
+    println!("This will open your browser to authenticate with Google.");
+
+    let mut command = build_login_command(&args);
+
+    println!("(Executing: {:?})\n", command);
+
+    let status = command
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .status()
+        .await
+        .context("Failed to execute 'gcloud'. Please ensure Google Cloud SDK is installed and in your PATH.")?;
+
+    if status.success() {
+        println!("\n{}", "Authentication successful!".green().bold());
+        println!("You can now use nblm commands.");
+    } else {
+        println!("\n{}", "Authentication failed.".red().bold());
+        if let Some(code) = status.code() {
+            println!("gcloud exited with code: {}", code);
+        }
+        anyhow::bail!("gcloud auth login failed");
+    }
+
+    Ok(())
+}
+
+async fn status() -> Result<()> {
+    // Check if we can get a token
+    let output = Command::new("gcloud")
+        .arg("auth")
+        .arg("print-access-token")
+        .output()
+        .await
+        .context("Failed to execute 'gcloud'. Please ensure Google Cloud SDK is installed.")?;
+
+    if !output.status.success() {
+        println!("{}", "Not authenticated.".yellow());
+        println!("Run '{}' to log in.", "nblm auth login".bold());
+        anyhow::bail!("Not authenticated");
+    }
+
+    // Try to get the current account email for better status info
+    let account_output = Command::new("gcloud")
+        .arg("config")
+        .arg("get-value")
+        .arg("account")
+        .output()
+        .await;
+
+    let account = if let Ok(out) = account_output {
+        String::from_utf8_lossy(&out.stdout).trim().to_string()
+    } else {
+        "Unknown account".to_string()
+    };
+
+    println!("{}", "Authenticated".green().bold());
+    if !account.is_empty() {
+        println!("Account: {}", account.cyan());
+    }
+    println!("Backend: gcloud");
+
+    Ok(())
+}
+
+fn build_login_command(args: &crate::args::LoginArgs) -> Command {
+    let mut command = Command::new("gcloud");
+    command.arg("auth").arg("login");
+
+    if args.drive_access {
+        println!("(Requesting Google Drive access)");
+        command.arg("--enable-gdrive-access");
+    }
+    command
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::args::LoginArgs;
+
+    #[test]
+    fn test_build_login_command_default() {
+        let args = LoginArgs {
+            drive_access: false,
+        };
+        let cmd = build_login_command(&args);
+        let cmd_str = format!("{:?}", cmd);
+        assert!(cmd_str.contains("gcloud"));
+        assert!(cmd_str.contains("auth"));
+        assert!(cmd_str.contains("login"));
+        assert!(!cmd_str.contains("--enable-gdrive-access"));
+    }
+
+    #[test]
+    fn test_build_login_command_drive_access() {
+        let args = LoginArgs { drive_access: true };
+        let cmd = build_login_command(&args);
+        let cmd_str = format!("{:?}", cmd);
+        assert!(cmd_str.contains("--enable-gdrive-access"));
+    }
+}

crates/nblm-cli/src/ops/mod.rs

@@ -1,4 +1,5 @@
 pub mod audio;
+pub mod auth;
 pub mod doctor;
 pub mod notebooks;
 pub mod sources;

crates/nblm-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nblm-core"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 license = "MIT"
 description = "Core library for NotebookLM Enterprise API client"

crates/nblm-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nblm-python"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2021"
 license = "MIT"
 description = "Python bindings for nblm-core (NotebookLM Enterprise API client)"