lincli 2026.4.3

Linear CLI — manage issues, projects, cycles, and more from the terminal
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use clap::{Args, Subcommand};
use console::style;
use dialoguer::{Password, theme::ColorfulTheme};

#[derive(Args, Debug)]
pub struct ConfigArgs {
    #[command(subcommand)]
    pub command: ConfigCommand,
}

#[derive(Subcommand, Debug)]
pub enum ConfigCommand {
    /// Set the Linear API key (saved to config file)
    SetToken,
    /// Show the stored API key (masked)
    GetToken,
    /// Print the config file path
    Path,
}

pub async fn execute(args: &ConfigArgs, json: bool, _debug: bool) -> anyhow::Result<()> {
    match &args.command {
        ConfigCommand::SetToken => set_token(json),
        ConfigCommand::GetToken => get_token(json),
        ConfigCommand::Path => print_path(json),
    }
}

fn set_token(json: bool) -> anyhow::Result<()> {
    let key = Password::with_theme(&ColorfulTheme::default())
        .with_prompt("Enter your Linear API key")
        .interact()?;

    if key.is_empty() {
        anyhow::bail!("API key cannot be empty");
    }

    crate::config::set_api_key(&key)?;

    let path = crate::config::config_path()
        .map(|p| p.display().to_string())
        .unwrap_or_else(|| "unknown".to_string());

    if json {
        let output = serde_json::json!({
            "saved": true,
            "path": path,
        });
        crate::output::print_json(&output);
    } else {
        println!(
            "{} API key saved to {}",
            style("✓").green().bold(),
            style(&path).cyan()
        );
    }

    Ok(())
}

fn get_token(json: bool) -> anyhow::Result<()> {
    match crate::config::get_api_key() {
        Some(key) => {
            let masked = mask_token(&key);
            if json {
                let output = serde_json::json!({
                    "token": masked,
                    "configured": true,
                });
                crate::output::print_json(&output);
            } else {
                println!("{masked}");
            }
        }
        None => {
            if json {
                let output = serde_json::json!({
                    "token": null,
                    "configured": false,
                });
                crate::output::print_json(&output);
            } else {
                println!("No API key configured. Run `lin config set-token` to set one.");
            }
        }
    }
    Ok(())
}

fn print_path(json: bool) -> anyhow::Result<()> {
    let path = crate::config::config_path()
        .map(|p| p.display().to_string())
        .unwrap_or_else(|| "unknown".to_string());

    if json {
        let output = serde_json::json!({ "path": path });
        crate::output::print_json(&output);
    } else {
        println!("{path}");
    }
    Ok(())
}

/// Mask a token, showing only the last 4 characters.
fn mask_token(token: &str) -> String {
    if token.len() <= 4 {
        return "*".repeat(token.len());
    }
    let visible = &token[token.len() - 4..];
    format!("{}{}", "*".repeat(token.len() - 4), visible)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_mask_token_normal() {
        assert_eq!(mask_token("lin_api_abcdef1234"), "**************1234");
    }

    #[test]
    fn test_mask_token_short() {
        assert_eq!(mask_token("abc"), "***");
    }

    #[test]
    fn test_mask_token_exactly_four() {
        assert_eq!(mask_token("abcd"), "****");
    }

    #[test]
    fn test_mask_token_five() {
        assert_eq!(mask_token("abcde"), "*bcde");
    }
}