clickup-cli 0.7.0

CLI for the ClickUp API, optimized for AI agents
Documentation 
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

use clap::Subcommand;
use crate::client::ClickUpClient;
use crate::commands::auth::resolve_token;
use crate::commands::workspace::resolve_workspace;
use crate::error::CliError;
use crate::output::OutputConfig;
use crate::Cli;

#[derive(Subcommand)]
pub enum UserCommands {
    /// Invite a user to the workspace
    Invite {
        /// Email address
        #[arg(long)]
        email: String,
        /// Grant admin role
        #[arg(long)]
        admin: bool,
        /// Custom role ID
        #[arg(long)]
        custom_role_id: Option<String>,
    },
    /// Get a workspace member by user ID
    Get {
        /// User ID
        id: String,
    },
    /// Update a workspace member
    Update {
        /// User ID
        id: String,
        /// New username
        #[arg(long)]
        username: Option<String>,
        /// Set admin role
        #[arg(long)]
        admin: Option<bool>,
        /// Custom role ID
        #[arg(long)]
        custom_role_id: Option<String>,
    },
    /// Remove a user from the workspace
    Remove {
        /// User ID
        id: String,
    },
}

const USER_FIELDS: &[&str] = &["id", "username", "email", "role"];

pub async fn execute(command: UserCommands, cli: &Cli) -> Result<(), CliError> {
    let token = resolve_token(cli)?;
    let client = ClickUpClient::new(&token, cli.timeout)?;
    let output = OutputConfig::from_cli(&cli.output, &cli.fields, cli.no_header, cli.quiet);
    let ws_id = resolve_workspace(cli)?;

    match command {
        UserCommands::Invite {
            email,
            admin,
            custom_role_id,
        } => {
            let mut body = serde_json::json!({
                "email": email,
                "admin": admin,
            });
            if let Some(r) = custom_role_id {
                body["custom_role_id"] = serde_json::Value::String(r);
            }
            let resp = client
                .post(&format!("/v2/team/{}/user", ws_id), &body)
                .await?;
            let member = resp.get("member").cloned().unwrap_or(resp);
            let user = member.get("user").cloned().unwrap_or(member);
            output.print_single(&user, USER_FIELDS, "id");
            Ok(())
        }
        UserCommands::Get { id } => {
            let resp = client
                .get(&format!("/v2/team/{}/user/{}", ws_id, id))
                .await?;
            let member = resp.get("member").cloned().unwrap_or(resp);
            let user = member.get("user").cloned().unwrap_or(member);
            output.print_single(&user, USER_FIELDS, "id");
            Ok(())
        }
        UserCommands::Update {
            id,
            username,
            admin,
            custom_role_id,
        } => {
            let mut body = serde_json::Map::new();
            if let Some(u) = username {
                body.insert("username".into(), serde_json::Value::String(u));
            }
            if let Some(a) = admin {
                body.insert("admin".into(), serde_json::Value::Bool(a));
            }
            if let Some(r) = custom_role_id {
                body.insert("custom_role_id".into(), serde_json::Value::String(r));
            }
            let resp = client
                .put(
                    &format!("/v2/team/{}/user/{}", ws_id, id),
                    &serde_json::Value::Object(body),
                )
                .await?;
            let member = resp.get("member").cloned().unwrap_or(resp);
            let user = member.get("user").cloned().unwrap_or(member);
            output.print_single(&user, USER_FIELDS, "id");
            Ok(())
        }
        UserCommands::Remove { id } => {
            client
                .delete(&format!("/v2/team/{}/user/{}", ws_id, id))
                .await?;
            output.print_message(&format!("User {} removed from workspace", id));
            Ok(())
        }
    }
}