systemprompt-cli 0.1.22

systemprompt.io OS - CLI for agent orchestration, AI operations, and system management
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
123
124
125
126
127
128
129
130
131
132
133
134

use anyhow::{Context, Result, bail};
use clap::{Args, Subcommand};
use std::fs;
use systemprompt_logging::CliService;
use systemprompt_models::{Profile, ProfileBootstrap};

use super::types::{SecurityConfigOutput, SecuritySetOutput};
use crate::CliConfig;
use crate::cli_settings::OutputFormat;
use crate::shared::{CommandResult, render_result};

#[derive(Debug, Subcommand)]
pub enum SecurityCommands {
    #[command(about = "Show security configuration")]
    Show,

    #[command(about = "Set security configuration value")]
    Set(SetArgs),
}

#[derive(Debug, Clone, Args)]
pub struct SetArgs {
    #[arg(long, help = "JWT issuer")]
    pub jwt_issuer: Option<String>,

    #[arg(long, help = "Access token expiry in seconds")]
    pub access_expiry: Option<i64>,

    #[arg(long, help = "Refresh token expiry in seconds")]
    pub refresh_expiry: Option<i64>,
}

pub fn execute(command: &SecurityCommands, config: &CliConfig) -> Result<()> {
    match command {
        SecurityCommands::Show => execute_show(),
        SecurityCommands::Set(args) => execute_set(args, config),
    }
}

fn execute_show() -> Result<()> {
    let profile = ProfileBootstrap::get()?;

    let output = SecurityConfigOutput {
        jwt_issuer: profile.security.issuer.clone(),
        access_token_expiry_seconds: profile.security.access_token_expiration,
        refresh_token_expiry_seconds: profile.security.refresh_token_expiration,
        audiences: profile
            .security
            .audiences
            .iter()
            .map(ToString::to_string)
            .collect(),
    };

    render_result(&CommandResult::card(output).with_title("Security Configuration"));

    Ok(())
}

fn execute_set(args: &SetArgs, config: &CliConfig) -> Result<()> {
    if args.jwt_issuer.is_none() && args.access_expiry.is_none() && args.refresh_expiry.is_none() {
        bail!("Must specify at least one option: --jwt-issuer, --access-expiry, --refresh-expiry");
    }

    let profile_path = ProfileBootstrap::get_path()?;
    let mut profile = load_profile(profile_path)?;

    let mut changes: Vec<SecuritySetOutput> = Vec::new();

    if let Some(ref issuer) = args.jwt_issuer {
        let old = profile.security.issuer.clone();
        profile.security.issuer.clone_from(issuer);
        changes.push(SecuritySetOutput {
            field: "jwt_issuer".to_string(),
            old_value: old,
            new_value: issuer.clone(),
            message: format!("Updated JWT issuer to {}", issuer),
        });
    }

    if let Some(expiry) = args.access_expiry {
        if expiry <= 0 {
            bail!("Access token expiry must be positive");
        }
        let old = profile.security.access_token_expiration;
        profile.security.access_token_expiration = expiry;
        changes.push(SecuritySetOutput {
            field: "access_token_expiration".to_string(),
            old_value: old.to_string(),
            new_value: expiry.to_string(),
            message: format!("Updated access token expiry to {} seconds", expiry),
        });
    }

    if let Some(expiry) = args.refresh_expiry {
        if expiry <= 0 {
            bail!("Refresh token expiry must be positive");
        }
        let old = profile.security.refresh_token_expiration;
        profile.security.refresh_token_expiration = expiry;
        changes.push(SecuritySetOutput {
            field: "refresh_token_expiration".to_string(),
            old_value: old.to_string(),
            new_value: expiry.to_string(),
            message: format!("Updated refresh token expiry to {} seconds", expiry),
        });
    }

    save_profile(&profile, profile_path)?;

    for change in &changes {
        render_result(&CommandResult::text(change.clone()).with_title("Security Updated"));
    }

    if config.output_format() == OutputFormat::Table {
        CliService::warning("Restart services for changes to take effect");
    }

    Ok(())
}

fn load_profile(path: &str) -> Result<Profile> {
    let content =
        fs::read_to_string(path).with_context(|| format!("Failed to read profile: {}", path))?;
    let profile: Profile = serde_yaml::from_str(&content)
        .with_context(|| format!("Failed to parse profile: {}", path))?;
    Ok(profile)
}

fn save_profile(profile: &Profile, path: &str) -> Result<()> {
    let content = serde_yaml::to_string(profile).context("Failed to serialize profile")?;
    fs::write(path, content).with_context(|| format!("Failed to write profile: {}", path))?;
    Ok(())
}