teams-cli 0.1.3__tar.gz → 0.1.5__tar.gz

{teams_cli-0.1.3 → teams_cli-0.1.5}/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.5](https://github.com/rvben/teams-cli/compare/v0.1.4...v0.1.5) - 2026-08-26
+
+### Added
+
+- **tui**: recover Microsoft sign-in in place ([8266887](https://github.com/rvben/teams-cli/commit/8266887feef3feb651fa4ae5348752be2703d36b))
+
+## [0.1.4](https://github.com/rvben/teams-cli/compare/v0.1.3...v0.1.4) - 2026-08-26
+
+### Added
+
+- **packaging**: add package-named launcher ([35a14d3](https://github.com/rvben/teams-cli/commit/35a14d329c5ca5a24f0e47c81cf29f30bad8773c))
+
 ## [0.1.3](https://github.com/rvben/teams-cli/compare/v0.1.2...v0.1.3) - 2026-08-26
 
 ### Added

{teams_cli-0.1.3 → teams_cli-0.1.5}/Cargo.lock

@@ -2964,7 +2964,7 @@ dependencies = [
 
 [[package]]
 name = "teams-cli"
-version = "0.1.3"
+version = "0.1.5"
 dependencies = [
  "assert_cmd",
  "base64 0.23.1",

{teams_cli-0.1.3 → teams_cli-0.1.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "teams-cli"
-version = "0.1.3"
+version = "0.1.5"
 edition = "2024"
 rust-version = "1.90"
 description = "A Microsoft Teams CLI and TUI designed equally for humans and agents"
@@ -16,6 +16,10 @@ categories = ["command-line-utilities"]
 name = "teams"
 path = "src/main.rs"
 
+[[bin]]
+name = "teams-cli"
+path = "src/teams_cli_alias.rs"
+
 [dependencies]
 base64 = "0.23"
 clap = { version = "4", features = ["derive", "env"] }

{teams_cli-0.1.3 → teams_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: teams-cli
-Version: 0.1.3
+Version: 0.1.5
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 License-File: LICENSE
@@ -28,9 +28,11 @@ For humans, no arguments open guided onboarding on first use and the TUI afterwa
 pipx install teams-cli
 # or
 cargo install teams-cli --locked
+# or run from PyPI without installing
+uvx teams-cli --help
 ```
 
-The PyPI distribution is named `teams-cli`; the executable is `teams`, matching the `jira-cli` → `jira` and `confluence-cli` → `confluence` family.
+The PyPI distribution provides both `teams` and `teams-cli` as executable names.
 
 To work from source:
 
@@ -71,6 +73,11 @@ Channel.ReadBasic.All Chat.Read Chat.Create ChatMessage.Send
 ChannelMessage.Send
 ```
 
+The TUI is also the recovery path: an unconfigured profile, missing credential,
+expired refresh session, or Microsoft `401` opens a focused connection screen.
+Press `Enter` or `a` to restore the normal terminal, complete Microsoft sign-in,
+and return directly to the inbox; `q` exits without changing anything.
+
 Reading channel history is intentionally separate because `ChannelMessage.Read.All` requires administrator consent. Request it only when needed:
 
 ```console

{teams_cli-0.1.3 → teams_cli-0.1.5}/README.md

@@ -12,9 +12,11 @@ For humans, no arguments open guided onboarding on first use and the TUI afterwa
 pipx install teams-cli
 # or
 cargo install teams-cli --locked
+# or run from PyPI without installing
+uvx teams-cli --help
 ```
 
-The PyPI distribution is named `teams-cli`; the executable is `teams`, matching the `jira-cli` → `jira` and `confluence-cli` → `confluence` family.
+The PyPI distribution provides both `teams` and `teams-cli` as executable names.
 
 To work from source:
 
@@ -55,6 +57,11 @@ Channel.ReadBasic.All Chat.Read Chat.Create ChatMessage.Send
 ChannelMessage.Send
 ```
 
+The TUI is also the recovery path: an unconfigured profile, missing credential,
+expired refresh session, or Microsoft `401` opens a focused connection screen.
+Press `Enter` or `a` to restore the normal terminal, complete Microsoft sign-in,
+and return directly to the inbox; `q` exits without changing anything.
+
 Reading channel history is intentionally separate because `ChannelMessage.Read.All` requires administrator consent. Request it only when needed:
 
 ```console

{teams_cli-0.1.3 → teams_cli-0.1.5}/src/config.rs

@@ -83,11 +83,7 @@ pub fn save(profile_name: &str, profile: Profile) -> Result<PathBuf, AppError> {
 
 pub fn load(requested: Option<&str>) -> Result<(String, Profile), AppError> {
     let config = read_file()?;
-    let name = requested
-        .map(str::to_owned)
-        .or_else(|| std::env::var("TEAMS_PROFILE").ok())
-        .or(config.active_profile)
-        .unwrap_or_else(|| "default".into());
+    let name = selected_profile_name_from(requested, config.active_profile.as_deref());
     let stored = config.profiles.get(&name);
     let client_id = std::env::var("TEAMS_CLIENT_ID")
         .ok()
@@ -118,6 +114,25 @@ pub fn load(requested: Option<&str>) -> Result<(String, Profile), AppError> {
     Ok((name, profile))
 }
 
+/// Resolve the profile a command would use without requiring that profile to
+/// be configured. Interactive recovery screens need the name even on first
+/// use, before there is a profile for [`load`] to return.
+pub fn selected_profile_name(requested: Option<&str>) -> Result<String, AppError> {
+    let config = read_file()?;
+    Ok(selected_profile_name_from(
+        requested,
+        config.active_profile.as_deref(),
+    ))
+}
+
+fn selected_profile_name_from(requested: Option<&str>, active: Option<&str>) -> String {
+    requested
+        .map(str::to_owned)
+        .or_else(|| std::env::var("TEAMS_PROFILE").ok())
+        .or_else(|| active.map(str::to_owned))
+        .unwrap_or_else(|| "default".into())
+}
+
 fn parse_bool(name: &str, value: &str) -> Result<bool, AppError> {
     match value.trim().to_ascii_lowercase().as_str() {
         "1" | "true" | "yes" | "on" => Ok(true),

{teams_cli-0.1.3 → teams_cli-0.1.5}/src/main.rs

@@ -393,6 +393,59 @@ async fn tui_command(profile_arg: Option<&str>, args: TuiArgs) -> Result<(), App
     if args.demo {
         return tui::run(tui::demo_data());
     }
+    let profile_name = config::selected_profile_name(profile_arg)?;
+    let mut reason_override = None;
+    loop {
+        match load_tui_data(profile_arg).await {
+            Ok(data) => return tui::run(data),
+            Err(error) if tui_auth_recoverable(&error) => {
+                let configured = config::configured_profile(profile_arg).is_some();
+                let reason = reason_override
+                    .take()
+                    .unwrap_or_else(|| tui_connection_reason(&error));
+                if tui::request_authentication(&profile_name, configured, &reason)?
+                    == tui::TuiExit::Quit
+                {
+                    return Ok(());
+                }
+
+                let auth_output = Output {
+                    format: OutputFormat::Text,
+                    quiet: false,
+                };
+                let result = if configured {
+                    let (_, profile) = config::load(profile_arg)?;
+                    auth::login(&profile_name, &profile, false, false, &auth_output)
+                        .await
+                        .map(|_| ())
+                } else {
+                    init(
+                        &profile_name,
+                        InitArgs {
+                            client_id: None,
+                            tenant: config::DEFAULT_TENANT.into(),
+                            no_login: false,
+                            device_code: false,
+                            channel_history: false,
+                            read_only: false,
+                        },
+                        auth_output,
+                    )
+                    .await
+                };
+                if let Err(error) = result {
+                    reason_override = Some(format!(
+                        "Sign-in did not complete: {} You can try again.",
+                        concise_error(&error)
+                    ));
+                }
+            }
+            Err(error) => return Err(error),
+        }
+    }
+}
+
+async fn load_tui_data(profile_arg: Option<&str>) -> Result<tui::TuiData, AppError> {
     let graph = client(profile_arg).await?;
     let me = graph.me().await?;
     let teams = graph.teams(50, 0).await?;
@@ -416,7 +469,7 @@ async fn tui_command(profile_arg: Option<&str>, args: TuiArgs) -> Result<(), App
             messages: vec![],
         });
     }
-    tui::run(tui::TuiData {
+    Ok(tui::TuiData {
         account: string_at(&me, "/displayName")
             .unwrap_or("Microsoft 365")
             .into(),
@@ -424,6 +477,63 @@ async fn tui_command(profile_arg: Option<&str>, args: TuiArgs) -> Result<(), App
     })
 }
 
+fn tui_auth_recoverable(error: &AppError) -> bool {
+    matches!(error, AppError::Auth(_))
+        || matches!(error, AppError::InvalidInput(message) if message.contains("is not configured"))
+}
+
+fn tui_connection_reason(error: &AppError) -> String {
+    match error {
+        AppError::InvalidInput(message) if message.contains("is not configured") => {
+            "This profile has not been connected yet.".into()
+        }
+        AppError::Auth(message)
+            if message.contains("not signed in") || message.contains("unreadable") =>
+        {
+            "This profile does not have a usable Microsoft sign-in yet.".into()
+        }
+        AppError::Auth(message) if message.contains("expired") => {
+            "Your saved Microsoft session has expired.".into()
+        }
+        _ => "Microsoft rejected the current session.".into(),
+    }
+}
+
+fn concise_error(error: &AppError) -> String {
+    error.to_string().trim_end_matches('.').to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tui_recovers_configuration_and_authentication_only() {
+        assert!(tui_auth_recoverable(&AppError::InvalidInput(
+            "profile 'work' is not configured; run `teams init`".into()
+        )));
+        assert!(tui_auth_recoverable(&AppError::Auth(
+            "session expired".into()
+        )));
+        assert!(!tui_auth_recoverable(&AppError::InvalidInput(
+            "invalid field selection".into()
+        )));
+        assert!(!tui_auth_recoverable(&AppError::RateLimit(None)));
+    }
+
+    #[test]
+    fn tui_connection_copy_is_actionable_without_shell_instructions() {
+        let reason = tui_connection_reason(&AppError::Auth(
+            "not signed in; run `teams auth login`".into(),
+        ));
+        assert_eq!(
+            reason,
+            "This profile does not have a usable Microsoft sign-in yet."
+        );
+        assert!(!reason.contains("teams auth login"));
+    }
+}
+
 #[derive(Serialize)]
 struct Check {
     name: &'static str,

teams_cli-0.1.5/src/teams_cli_alias.rs

@@ -0,0 +1,30 @@
+use std::env;
+use std::fmt::Display;
+use std::process::{self, Command};
+
+const COMMAND: &str = "teams";
+
+fn fail(error: impl Display) -> ! {
+    eprintln!("teams-cli: failed to launch {COMMAND}: {error}");
+    process::exit(126);
+}
+
+fn main() {
+    let mut executable = env::current_exe().unwrap_or_else(|error| fail(error));
+    executable.set_file_name(format!("{COMMAND}{}", env::consts::EXE_SUFFIX));
+
+    let mut command = Command::new(executable);
+    command.args(env::args_os().skip(1));
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::process::CommandExt;
+        fail(command.exec());
+    }
+
+    #[cfg(not(unix))]
+    match command.status() {
+        Ok(status) => process::exit(status.code().unwrap_or(1)),
+        Err(error) => fail(error),
+    }
+}

{teams_cli-0.1.3 → teams_cli-0.1.5}/src/tui.rs

@@ -1,7 +1,7 @@
 use std::io::{self, IsTerminal};
 use std::time::Duration;
 
-use crossterm::event::{self, Event, KeyCode, KeyEventKind};
+use crossterm::event::{self, Event, KeyCode, KeyEventKind, KeyModifiers};
 use crossterm::execute;
 use crossterm::terminal::{
     EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
@@ -21,6 +21,32 @@ const FOCUS: Color = Color::Rgb(102, 194, 255);
 const LIVE: Color = Color::Rgb(255, 119, 107);
 const SURFACE: Color = Color::Rgb(20, 23, 30);
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum TuiExit {
+    Quit,
+    Authenticate,
+}
+
+struct TerminalGuard;
+
+impl TerminalGuard {
+    fn enter() -> Result<Self, AppError> {
+        enable_raw_mode()?;
+        if let Err(error) = execute!(io::stdout(), EnterAlternateScreen) {
+            let _ = disable_raw_mode();
+            return Err(error.into());
+        }
+        Ok(Self)
+    }
+}
+
+impl Drop for TerminalGuard {
+    fn drop(&mut self) {
+        let _ = disable_raw_mode();
+        let _ = execute!(io::stdout(), LeaveAlternateScreen);
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct TuiData {
     pub account: String,
@@ -119,17 +145,46 @@ pub fn snapshot(width: u16, height: u16) -> Result<String, AppError> {
     Ok(output)
 }
 
+pub fn connection_snapshot(
+    width: u16,
+    height: u16,
+    profile: &str,
+    configured: bool,
+    reason: &str,
+) -> Result<String, AppError> {
+    let backend = TestBackend::new(width.max(48), height.max(18));
+    let mut terminal = Terminal::new(backend).expect("test backend is infallible");
+    terminal
+        .draw(|frame| draw_connection(frame, profile, configured, reason))
+        .expect("test backend is infallible");
+    Ok(buffer_text(terminal.backend().buffer()))
+}
+
+fn buffer_text(buffer: &ratatui::buffer::Buffer) -> String {
+    let mut output = String::new();
+    for y in 0..buffer.area.height {
+        let mut line = String::new();
+        for x in 0..buffer.area.width {
+            line.push_str(buffer[(x, y)].symbol());
+        }
+        output.push_str(line.trim_end());
+        output.push('\n');
+    }
+    while output.ends_with("\n\n") {
+        output.pop();
+    }
+    output
+}
+
 pub fn run(data: TuiData) -> Result<(), AppError> {
     if !io::stdout().is_terminal() || !io::stdin().is_terminal() {
         return Err(AppError::NonInteractive("`teams tui` needs a terminal; use `teams tui --demo --snapshot` for an inspectable frame".into()));
     }
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout);
+    let _terminal_guard = TerminalGuard::enter()?;
+    let backend = CrosstermBackend::new(io::stdout());
     let mut terminal = Terminal::new(backend)?;
     let mut app = App { data, selected: 0 };
-    let result = (|| -> Result<(), AppError> {
+    (|| -> Result<(), AppError> {
         loop {
             terminal.draw(|frame| draw(frame, &app))?;
             if event::poll(Duration::from_millis(150))?
@@ -140,6 +195,7 @@ pub fn run(data: TuiData) -> Result<(), AppError> {
                 }
                 match key.code {
                     KeyCode::Char('q') | KeyCode::Esc => break,
+                    KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => break,
                     KeyCode::Down | KeyCode::Char('j') => {
                         app.selected =
                             (app.selected + 1).min(app.data.conversations.len().saturating_sub(1))
@@ -152,14 +208,111 @@ pub fn run(data: TuiData) -> Result<(), AppError> {
             }
         }
         Ok(())
-    })();
-    let cleanup = (|| -> Result<(), AppError> {
-        disable_raw_mode()?;
-        execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-        terminal.show_cursor()?;
-        Ok(())
-    })();
-    result.and(cleanup)
+    })()
+}
+
+/// Present an actionable connection state inside the same terminal experience.
+/// Returning first restores the alternate screen before the caller opens a
+/// browser or prints device-code instructions.
+pub fn request_authentication(
+    profile: &str,
+    configured: bool,
+    reason: &str,
+) -> Result<TuiExit, AppError> {
+    if !io::stdout().is_terminal() || !io::stdin().is_terminal() {
+        return Err(AppError::NonInteractive(
+            "`teams tui` needs a terminal; run `teams auth login --device-code` for headless sign-in"
+                .into(),
+        ));
+    }
+    let _terminal_guard = TerminalGuard::enter()?;
+    let backend = CrosstermBackend::new(io::stdout());
+    let mut terminal = Terminal::new(backend)?;
+    loop {
+        terminal.draw(|frame| draw_connection(frame, profile, configured, reason))?;
+        if event::poll(Duration::from_millis(150))?
+            && let Event::Key(key) = event::read()?
+        {
+            if key.kind != KeyEventKind::Press {
+                continue;
+            }
+            match key.code {
+                KeyCode::Enter | KeyCode::Char('a') => return Ok(TuiExit::Authenticate),
+                KeyCode::Char('q') | KeyCode::Esc => return Ok(TuiExit::Quit),
+                KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                    return Ok(TuiExit::Quit);
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+fn draw_connection(frame: &mut ratatui::Frame, profile: &str, configured: bool, reason: &str) {
+    let area = frame.area();
+    frame.render_widget(Block::default().style(Style::default().bg(SURFACE)), area);
+    let panel_width = area.width.saturating_sub(2).clamp(1, 74);
+    let panel_height = area.height.saturating_sub(2).clamp(1, 12);
+    let panel = Rect {
+        x: area.x + area.width.saturating_sub(panel_width) / 2,
+        y: area.y + area.height.saturating_sub(panel_height) / 2,
+        width: panel_width,
+        height: panel_height,
+    };
+    let title = if configured {
+        " SIGN-IN REQUIRED "
+    } else {
+        " CONNECT MICROSOFT TEAMS "
+    };
+    let action = if configured {
+        "Continue with Microsoft sign-in. Your password is never shared with teams-cli."
+    } else {
+        "Set up this profile and continue with secure Microsoft sign-in."
+    };
+    let content = vec![
+        Line::styled(
+            if configured {
+                "Your Teams session needs attention"
+            } else {
+                "Bring your Teams workspace into focus"
+            },
+            Style::default().fg(INK).add_modifier(Modifier::BOLD),
+        ),
+        Line::styled(format!("Profile: {profile}"), Style::default().fg(MUTED)),
+        Line::raw(""),
+        Line::styled(reason, Style::default().fg(INK)),
+        Line::styled(action, Style::default().fg(MUTED)),
+        Line::raw(""),
+        Line::from(vec![
+            Span::styled(
+                " enter / a ",
+                Style::default()
+                    .fg(Color::Black)
+                    .bg(FOCUS)
+                    .add_modifier(Modifier::BOLD),
+            ),
+            Span::styled(
+                if configured {
+                    " sign in   "
+                } else {
+                    " set up   "
+                },
+                Style::default().fg(MUTED),
+            ),
+            Span::styled("q", Style::default().fg(INK)),
+            Span::styled(" quit", Style::default().fg(MUTED)),
+        ]),
+    ];
+    frame.render_widget(
+        Paragraph::new(content).wrap(Wrap { trim: true }).block(
+            Block::default()
+                .title(title)
+                .borders(Borders::ALL)
+                .border_style(Style::default().fg(FOCUS))
+                .padding(ratatui::widgets::Padding::horizontal(2)),
+        ),
+        panel,
+    );
 }
 
 fn draw(frame: &mut ratatui::Frame, app: &App) {
@@ -312,4 +465,16 @@ mod tests {
         assert!(frame.contains("release candidate is green"));
         assert!(frame.contains("q quit"));
     }
+
+    #[test]
+    fn connection_snapshot_has_a_clear_recovery_action() {
+        let frame =
+            super::connection_snapshot(80, 22, "work", true, "Your saved session has expired.")
+                .unwrap();
+        assert!(frame.contains("SIGN-IN REQUIRED"));
+        assert!(frame.contains("Profile: work"));
+        assert!(frame.contains("enter / a"));
+        assert!(frame.contains("sign in"));
+        assert!(frame.contains("q quit"));
+    }
 }

teams_cli-0.1.5/tests/package_alias.rs

@@ -0,0 +1,20 @@
+use std::process::{Command, Output};
+
+fn run(executable: &str, argument: &str) -> Output {
+    Command::new(executable)
+        .arg(argument)
+        .output()
+        .expect("CLI should start")
+}
+
+#[test]
+fn package_named_alias_forwards_arguments_output_and_status() {
+    for argument in ["--version", "--__alias-test-invalid"] {
+        let primary = run(env!("CARGO_BIN_EXE_teams"), argument);
+        let alias = run(env!("CARGO_BIN_EXE_teams-cli"), argument);
+
+        assert_eq!(alias.status.code(), primary.status.code());
+        assert_eq!(alias.stdout, primary.stdout);
+        assert_eq!(alias.stderr, primary.stderr);
+    }
+}