Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use std::{
io::{self, IsTerminal, Read},
path::PathBuf,
};
use clap::{Args, Subcommand, ValueEnum};
use reqwest::Method;
use serde_json::{Map, Value, json};
use crate::{
OutputFormat, agent_client,
caps::{AgentClient, opaque_id},
confirmation, resolve_format,
};
#[derive(Args)]
pub struct OrganizationsArgs {
#[command(subcommand)]
command: OrganizationCommands,
}
#[derive(Subcommand)]
enum OrganizationCommands {
List(FormatArgs),
Create(OrganizationCreateArgs),
Get(OrganizationArgs),
Members(OrganizationArgs),
Invites(OrganizationArgs),
Billing(OrganizationBillingArgs),
Storage(OrganizationStorageArgs),
Update(OrganizationUpdateArgs),
Icon(OrganizationIconArgs),
ShareableIcon(OrganizationIconArgs),
Settings(OrganizationSettingsArgs),
Invite(OrganizationInviteArgs),
Member(OrganizationMemberArgs),
Domain(OrganizationDomainArgs),
Delete(OrganizationDeleteArgs),
}
#[derive(Args)]
struct FormatArgs {
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationArgs {
organization: String,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationCreateArgs {
name: String,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationIconArgs {
#[command(subcommand)]
command: OrganizationIconCommands,
}
#[derive(Subcommand)]
enum OrganizationIconCommands {
Set(OrganizationIconSetArgs),
Remove(OrganizationIconRemoveArgs),
}
#[derive(Args)]
struct OrganizationIconSetArgs {
organization: String,
image: PathBuf,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationIconRemoveArgs {
organization: String,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationBillingArgs {
#[command(subcommand)]
command: OrganizationBillingCommands,
}
#[derive(Subcommand)]
enum OrganizationBillingCommands {
Get(OrganizationArgs),
Checkout(OrganizationBillingCheckoutArgs),
Portal(OrganizationBillingPortalArgs),
}
#[derive(Clone, Copy, ValueEnum)]
enum BillingInterval {
Monthly,
Yearly,
}
impl BillingInterval {
const fn as_str(self) -> &'static str {
match self {
Self::Monthly => "monthly",
Self::Yearly => "yearly",
}
}
}
#[derive(Args)]
struct OrganizationBillingCheckoutArgs {
organization: String,
#[arg(long, value_enum, default_value_t = BillingInterval::Yearly)]
interval: BillingInterval,
#[arg(long)]
quantity: Option<u32>,
#[arg(long)]
no_open: bool,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationBillingPortalArgs {
organization: String,
#[arg(long)]
no_open: bool,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationStorageArgs {
#[command(subcommand)]
command: OrganizationStorageCommands,
}
#[derive(Subcommand)]
enum OrganizationStorageCommands {
List(OrganizationArgs),
S3(OrganizationS3Args),
Provider(OrganizationStorageProviderArgs),
GoogleDrive(OrganizationGoogleDriveArgs),
}
#[derive(Args)]
struct OrganizationS3Args {
#[command(subcommand)]
command: OrganizationS3Commands,
}
#[derive(Subcommand)]
enum OrganizationS3Commands {
Set(OrganizationS3ConfigArgs),
Test(OrganizationS3ConfigArgs),
Remove(OrganizationS3RemoveArgs),
}
#[derive(Args)]
struct OrganizationS3ConfigArgs {
organization: String,
#[arg(long, default_value = "aws")]
provider: String,
#[arg(long, default_value = "https://s3.amazonaws.com")]
endpoint: String,
#[arg(long)]
bucket: String,
#[arg(long, default_value = "us-east-1")]
region: String,
#[arg(long, conflicts_with = "credentials_stdin")]
reuse_credentials: bool,
#[arg(long, conflicts_with = "reuse_credentials")]
credentials_stdin: bool,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationS3RemoveArgs {
organization: String,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Clone, Copy, ValueEnum)]
enum OrganizationStorageProvider {
S3,
GoogleDrive,
}
impl OrganizationStorageProvider {
const fn as_str(self) -> &'static str {
match self {
Self::S3 => "s3",
Self::GoogleDrive => "googleDrive",
}
}
}
#[derive(Args)]
struct OrganizationStorageProviderArgs {
organization: String,
#[arg(long, value_enum)]
provider: OrganizationStorageProvider,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationGoogleDriveArgs {
#[command(subcommand)]
command: OrganizationGoogleDriveCommands,
}
#[derive(Subcommand)]
enum OrganizationGoogleDriveCommands {
Connect(OrganizationGoogleDriveConnectArgs),
Folders(OrganizationGoogleDriveFoldersArgs),
Location(OrganizationGoogleDriveLocationArgs),
Disconnect(OrganizationGoogleDriveDisconnectArgs),
}
#[derive(Args)]
struct OrganizationGoogleDriveConnectArgs {
organization: String,
#[arg(long)]
no_open: bool,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationGoogleDriveFoldersArgs {
organization: String,
#[arg(long)]
parent_id: Option<String>,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationGoogleDriveLocationArgs {
organization: String,
folder_id: String,
#[arg(long)]
folder_name: Option<String>,
#[arg(long)]
drive_id: Option<String>,
#[arg(long)]
drive_name: Option<String>,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationGoogleDriveDisconnectArgs {
organization: String,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Clone, Copy, ValueEnum)]
enum OrganizationRole {
Admin,
Member,
}
impl OrganizationRole {
const fn as_str(self) -> &'static str {
match self {
Self::Admin => "admin",
Self::Member => "member",
}
}
}
#[derive(Args)]
struct OrganizationUpdateArgs {
organization: String,
#[arg(long)]
name: Option<String>,
#[arg(long, conflicts_with = "clear_allowed_email_domain")]
allowed_email_domain: Option<String>,
#[arg(long)]
clear_allowed_email_domain: bool,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationSettingsArgs {
organization: String,
#[arg(long)]
disable_summary: Option<bool>,
#[arg(long)]
disable_captions: Option<bool>,
#[arg(long)]
disable_chapters: Option<bool>,
#[arg(long)]
disable_reactions: Option<bool>,
#[arg(long)]
disable_transcript: Option<bool>,
#[arg(long)]
disable_comments: Option<bool>,
#[arg(long)]
hide_shareable_link_cap_logo: Option<bool>,
#[arg(long)]
shareable_link_use_organization_icon: Option<bool>,
#[arg(long)]
ai_generation_language: Option<String>,
#[arg(long)]
default_playback_speed: Option<f64>,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationInviteArgs {
#[command(subcommand)]
command: OrganizationInviteCommands,
}
#[derive(Subcommand)]
enum OrganizationInviteCommands {
Add(OrganizationInviteAddArgs),
Remove(OrganizationInviteRemoveArgs),
}
#[derive(Args)]
struct OrganizationInviteAddArgs {
organization: String,
#[arg(long)]
email: String,
#[arg(long, value_enum, default_value_t = OrganizationRole::Member)]
role: OrganizationRole,
#[arg(long, help = "Create a link without delivering the invitation email")]
no_email: bool,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationInviteRemoveArgs {
organization: String,
invite_id: String,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationMemberArgs {
#[command(subcommand)]
command: OrganizationMemberCommands,
}
#[derive(Subcommand)]
enum OrganizationMemberCommands {
Role(OrganizationMemberRoleArgs),
Seat(OrganizationMemberSeatArgs),
Remove(OrganizationMemberRemoveArgs),
}
#[derive(Args)]
struct OrganizationMemberRoleArgs {
organization: String,
member_id: String,
#[arg(long, value_enum)]
role: OrganizationRole,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationMemberRemoveArgs {
organization: String,
member_id: String,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationMemberSeatArgs {
organization: String,
member_id: String,
#[arg(long, conflicts_with = "disable")]
enable: bool,
#[arg(long, conflicts_with = "enable")]
disable: bool,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationDeleteArgs {
organization: String,
#[arg(long)]
wait: bool,
#[arg(long, default_value_t = 600)]
timeout: u64,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationDomainArgs {
#[command(subcommand)]
command: OrganizationDomainCommands,
}
#[derive(Subcommand)]
enum OrganizationDomainCommands {
Set(OrganizationDomainSetArgs),
Remove(OrganizationDomainOperationArgs),
Verify(OrganizationDomainOperationArgs),
}
#[derive(Args)]
struct OrganizationDomainSetArgs {
organization: String,
domain: String,
#[arg(long)]
wait: bool,
#[arg(long, default_value_t = 600)]
timeout: u64,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
#[derive(Args)]
struct OrganizationDomainOperationArgs {
organization: String,
#[arg(long)]
wait: bool,
#[arg(long, default_value_t = 600)]
timeout: u64,
#[arg(long)]
yes: bool,
#[arg(long, value_enum, default_value_t = OutputFormat::Text)]
format: OutputFormat,
}
async fn run_operation(
method: Method,
path: &str,
wait: bool,
timeout: u64,
format: OutputFormat,
global_json: bool,
) -> Result<(), String> {
let client = AgentClient::from_credentials().map_err(|error| error.to_string())?;
let mut value = client
.mutate_json_confirmed(method, path, &json!({}))
.await
.map_err(|error| error.to_string())?;
if wait {
let operation_id = value
.get("id")
.and_then(Value::as_str)
.ok_or_else(|| "Cap returned an invalid operation".to_string())?;
value = crate::jobs::wait_operation(&client, operation_id, timeout)
.await
.map_err(|error| error.to_string())?;
}
agent_client::print_value(&value, resolve_format(global_json, format))
}
fn read_s3_credentials(reuse: bool, credentials_stdin: bool) -> Result<(String, String), String> {
if reuse {
return Ok((String::new(), String::new()));
}
if credentials_stdin {
let mut value = String::new();
io::stdin()
.lock()
.take(16 * 1024)
.read_to_string(&mut value)
.map_err(|error| error.to_string())?;
let lines = value.lines().collect::<Vec<_>>();
if lines.len() != 2 || lines.iter().any(|line| line.is_empty()) {
return Err(
"--credentials-stdin expects the access key ID and secret access key on exactly two non-empty lines"
.to_string(),
);
}
return Ok((lines[0].to_string(), lines[1].to_string()));
}
if !io::stdin().is_terminal() {
return Err(
"Non-interactive S3 configuration requires --credentials-stdin or --reuse-credentials"
.to_string(),
);
}
let access_key_id =
rpassword::prompt_password("S3 access key ID: ").map_err(|error| error.to_string())?;
let secret_access_key =
rpassword::prompt_password("S3 secret access key: ").map_err(|error| error.to_string())?;
if access_key_id.is_empty() || secret_access_key.is_empty() {
return Err("S3 credentials cannot be empty".to_string());
}
Ok((access_key_id, secret_access_key))
}
fn s3_config_body(args: &OrganizationS3ConfigArgs) -> Result<Value, String> {
let (access_key_id, secret_access_key) =
read_s3_credentials(args.reuse_credentials, args.credentials_stdin)?;
Ok(json!({
"provider": args.provider,
"accessKeyId": access_key_id,
"secretAccessKey": secret_access_key,
"endpoint": args.endpoint,
"bucketName": args.bucket,
"region": args.region,
}))
}
impl OrganizationsArgs {
pub async fn run(self, global_json: bool) -> Result<(), String> {
match self.command {
OrganizationCommands::List(args) => {
agent_client::read("/organizations", global_json, args.format).await
}
OrganizationCommands::Create(args) => {
confirmation::require(args.yes, "Create the organization")?;
agent_client::mutate_confirmed(
Method::POST,
"/organizations",
&json!({ "name": args.name }),
global_json,
args.format,
)
.await
}
OrganizationCommands::Get(args) => {
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::read(&format!("/organizations/{id}"), global_json, args.format).await
}
OrganizationCommands::Members(args) => {
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::read(
&format!("/organizations/{id}/members"),
global_json,
args.format,
)
.await
}
OrganizationCommands::Invites(args) => {
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::read(
&format!("/organizations/{id}/invites"),
global_json,
args.format,
)
.await
}
OrganizationCommands::Billing(args) => match args.command {
OrganizationBillingCommands::Get(args) => {
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::read(
&format!("/organizations/{id}/billing"),
global_json,
args.format,
)
.await
}
OrganizationBillingCommands::Checkout(args) => {
confirmation::require(args.yes, "Create the Cap Pro checkout")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let client =
AgentClient::from_credentials().map_err(|error| error.to_string())?;
let mut body = Map::from_iter([(
"interval".to_string(),
Value::String(args.interval.as_str().to_string()),
)]);
if let Some(quantity) = args.quantity {
body.insert("quantity".to_string(), Value::from(quantity));
}
let value = client
.mutate_json_confirmed(
Method::POST,
&format!("/organizations/{id}/billing/checkout"),
&Value::Object(body),
)
.await
.map_err(|error| error.to_string())?;
agent_client::open_browser_action(&value, args.no_open);
agent_client::print_value(&value, resolve_format(global_json, args.format))
}
OrganizationBillingCommands::Portal(args) => {
confirmation::require(args.yes, "Open the Cap billing portal")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let client =
AgentClient::from_credentials().map_err(|error| error.to_string())?;
let value = client
.mutate_json_confirmed(
Method::POST,
&format!("/organizations/{id}/billing/portal"),
&json!({}),
)
.await
.map_err(|error| error.to_string())?;
agent_client::open_browser_action(&value, args.no_open);
agent_client::print_value(&value, resolve_format(global_json, args.format))
}
},
OrganizationCommands::Storage(args) => match args.command {
OrganizationStorageCommands::List(args) => {
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::read(
&format!("/organizations/{id}/storage-integrations"),
global_json,
args.format,
)
.await
}
OrganizationStorageCommands::S3(args) => match args.command {
OrganizationS3Commands::Set(args) => {
confirmation::require(args.yes, "Configure organization S3 storage")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let body = s3_config_body(&args)?;
agent_client::mutate_confirmed(
Method::PUT,
&format!("/organizations/{id}/storage/s3"),
&body,
global_json,
args.format,
)
.await
}
OrganizationS3Commands::Test(args) => {
confirmation::require(args.yes, "Test organization S3 storage")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let body = s3_config_body(&args)?;
agent_client::mutate_confirmed(
Method::POST,
&format!("/organizations/{id}/storage/s3/test"),
&body,
global_json,
args.format,
)
.await
}
OrganizationS3Commands::Remove(args) => {
confirmation::require(args.yes, "Remove organization S3 storage")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::DELETE,
&format!("/organizations/{id}/storage/s3"),
&json!({}),
global_json,
args.format,
)
.await
}
},
OrganizationStorageCommands::Provider(args) => {
confirmation::require(args.yes, "Change the organization storage provider")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::PATCH,
&format!("/organizations/{id}/storage/provider"),
&json!({ "provider": args.provider.as_str() }),
global_json,
args.format,
)
.await
}
OrganizationStorageCommands::GoogleDrive(args) => match args.command {
OrganizationGoogleDriveCommands::Connect(args) => {
confirmation::require(args.yes, "Connect organization Google Drive")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let client =
AgentClient::from_credentials().map_err(|error| error.to_string())?;
let value = client
.mutate_json_confirmed(
Method::POST,
&format!("/organizations/{id}/storage/google-drive/connect"),
&json!({}),
)
.await
.map_err(|error| error.to_string())?;
agent_client::open_browser_action(&value, args.no_open);
agent_client::print_value(&value, resolve_format(global_json, args.format))
}
OrganizationGoogleDriveCommands::Folders(args) => {
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let query = agent_client::query(&[("parentId", args.parent_id)]);
let path = if query.is_empty() {
format!("/organizations/{id}/storage/google-drive/folders")
} else {
format!("/organizations/{id}/storage/google-drive/folders?{query}")
};
agent_client::read(&path, global_json, args.format).await
}
OrganizationGoogleDriveCommands::Location(args) => {
confirmation::require(
args.yes,
"Change the organization Google Drive location",
)?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::PUT,
&format!("/organizations/{id}/storage/google-drive/location"),
&json!({
"folderId": args.folder_id,
"folderName": args.folder_name,
"driveId": args.drive_id,
"driveName": args.drive_name,
}),
global_json,
args.format,
)
.await
}
OrganizationGoogleDriveCommands::Disconnect(args) => {
confirmation::require(args.yes, "Disconnect organization Google Drive")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::DELETE,
&format!("/organizations/{id}/storage/google-drive"),
&json!({}),
global_json,
args.format,
)
.await
}
},
},
OrganizationCommands::Update(args) => {
confirmation::require(args.yes, "Update the organization")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let mut body = Map::new();
if let Some(name) = args.name {
body.insert("name".to_string(), Value::String(name));
}
if let Some(domain) = args.allowed_email_domain {
body.insert("allowedEmailDomain".to_string(), Value::String(domain));
} else if args.clear_allowed_email_domain {
body.insert("allowedEmailDomain".to_string(), Value::Null);
}
if body.is_empty() {
return Err(
"Provide --name, --allowed-email-domain, or --clear-allowed-email-domain"
.to_string(),
);
}
agent_client::mutate_confirmed(
Method::PATCH,
&format!("/organizations/{id}"),
&Value::Object(body),
global_json,
args.format,
)
.await
}
OrganizationCommands::Icon(args) => match args.command {
OrganizationIconCommands::Set(args) => {
confirmation::require(args.yes, "Update the organization icon")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let body = agent_client::image_payload(&args.image)?;
agent_client::mutate_confirmed(
Method::PUT,
&format!("/organizations/{id}/icon"),
&body,
global_json,
args.format,
)
.await
}
OrganizationIconCommands::Remove(args) => {
confirmation::require(args.yes, "Remove the organization icon")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::DELETE,
&format!("/organizations/{id}/icon"),
&json!({}),
global_json,
args.format,
)
.await
}
},
OrganizationCommands::ShareableIcon(args) => match args.command {
OrganizationIconCommands::Set(args) => {
confirmation::require(args.yes, "Update the shareable link icon")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let body = agent_client::image_payload(&args.image)?;
agent_client::mutate_confirmed(
Method::PUT,
&format!("/organizations/{id}/shareable-link-icon"),
&body,
global_json,
args.format,
)
.await
}
OrganizationIconCommands::Remove(args) => {
confirmation::require(args.yes, "Remove the shareable link icon")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::DELETE,
&format!("/organizations/{id}/shareable-link-icon"),
&json!({}),
global_json,
args.format,
)
.await
}
},
OrganizationCommands::Settings(args) => {
confirmation::require(args.yes, "Update organization preferences")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let mut body = Map::new();
for (key, value) in [
("disableSummary", args.disable_summary),
("disableCaptions", args.disable_captions),
("disableChapters", args.disable_chapters),
("disableReactions", args.disable_reactions),
("disableTranscript", args.disable_transcript),
("disableComments", args.disable_comments),
(
"hideShareableLinkCapLogo",
args.hide_shareable_link_cap_logo,
),
(
"shareableLinkUseOrganizationIcon",
args.shareable_link_use_organization_icon,
),
] {
if let Some(value) = value {
body.insert(key.to_string(), Value::Bool(value));
}
}
if let Some(language) = args.ai_generation_language {
body.insert("aiGenerationLanguage".to_string(), Value::String(language));
}
if let Some(speed) = args.default_playback_speed {
let speed = serde_json::Number::from_f64(speed)
.ok_or_else(|| "Default playback speed must be finite".to_string())?;
body.insert("defaultPlaybackSpeed".to_string(), Value::Number(speed));
}
if body.is_empty() {
return Err("Provide at least one organization preference".to_string());
}
agent_client::mutate_confirmed(
Method::PATCH,
&format!("/organizations/{id}/settings"),
&Value::Object(body),
global_json,
args.format,
)
.await
}
OrganizationCommands::Invite(args) => match args.command {
OrganizationInviteCommands::Add(args) => {
confirmation::require(
args.yes,
if args.no_email {
"Create the organization invite link"
} else {
"Create and email the organization invite"
},
)?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::POST,
&format!("/organizations/{id}/invites"),
&json!({
"email": args.email,
"role": args.role.as_str(),
"sendEmail": !args.no_email,
}),
global_json,
args.format,
)
.await
}
OrganizationInviteCommands::Remove(args) => {
confirmation::require(args.yes, "Remove the organization invite")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let invite_id = opaque_id(&args.invite_id, "Invite ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::DELETE,
&format!("/organizations/{id}/invites/{invite_id}"),
&json!({}),
global_json,
args.format,
)
.await
}
},
OrganizationCommands::Member(args) => match args.command {
OrganizationMemberCommands::Role(args) => {
confirmation::require(args.yes, "Change the organization member role")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let member_id = opaque_id(&args.member_id, "Member ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::PATCH,
&format!("/organizations/{id}/members/{member_id}"),
&json!({ "role": args.role.as_str() }),
global_json,
args.format,
)
.await
}
OrganizationMemberCommands::Seat(args) => {
confirmation::require(args.yes, "Change the organization member Pro seat")?;
if args.enable == args.disable {
return Err("Provide exactly one of --enable or --disable".to_string());
}
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let member_id = opaque_id(&args.member_id, "Member ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::PATCH,
&format!("/organizations/{id}/members/{member_id}/seat"),
&json!({ "enabled": args.enable }),
global_json,
args.format,
)
.await
}
OrganizationMemberCommands::Remove(args) => {
confirmation::require(args.yes, "Remove the organization member")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let member_id = opaque_id(&args.member_id, "Member ID")
.map_err(|error| error.to_string())?;
agent_client::mutate_confirmed(
Method::DELETE,
&format!("/organizations/{id}/members/{member_id}"),
&json!({}),
global_json,
args.format,
)
.await
}
},
OrganizationCommands::Delete(args) => {
confirmation::require(
args.yes,
"Permanently delete the organization and all of its Caps",
)?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
run_operation(
Method::DELETE,
&format!("/organizations/{id}"),
args.wait,
args.timeout,
args.format,
global_json,
)
.await
}
OrganizationCommands::Domain(args) => match args.command {
OrganizationDomainCommands::Set(args) => {
confirmation::require(args.yes, "Set the organization custom domain")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
let client =
AgentClient::from_credentials().map_err(|error| error.to_string())?;
let mut value = client
.mutate_json_confirmed(
Method::PUT,
&format!("/organizations/{id}/domain"),
&json!({ "domain": args.domain }),
)
.await
.map_err(|error| error.to_string())?;
if args.wait {
let operation_id = value
.get("id")
.and_then(Value::as_str)
.ok_or_else(|| "Cap returned an invalid operation".to_string())?;
value = crate::jobs::wait_operation(&client, operation_id, args.timeout)
.await
.map_err(|error| error.to_string())?;
}
agent_client::print_value(&value, resolve_format(global_json, args.format))
}
OrganizationDomainCommands::Remove(args) => {
confirmation::require(args.yes, "Remove the organization custom domain")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
run_operation(
Method::DELETE,
&format!("/organizations/{id}/domain"),
args.wait,
args.timeout,
args.format,
global_json,
)
.await
}
OrganizationDomainCommands::Verify(args) => {
confirmation::require(args.yes, "Verify the organization custom domain")?;
let id = opaque_id(&args.organization, "Organization ID")
.map_err(|error| error.to_string())?;
run_operation(
Method::POST,
&format!("/organizations/{id}/domain/verify"),
args.wait,
args.timeout,
args.format,
global_json,
)
.await
}
},
}
}
}