systemprompt-cli 0.19.0

Unified CLI for systemprompt.io AI governance: agent orchestration, MCP governance, analytics, profiles, cloud deploy, and self-hosted operations.
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

//! `admin agents` command group: manage A2A agent configurations and runtime.
//!
//! Exposes [`AgentsCommands`] covering the agent lifecycle — list, show,
//! validate, create, edit, delete, status, logs — plus A2A interaction
//! (registry discovery, message, task, tools) and direct `run`. Each variant
//! dispatches to a sibling module that returns a
//! [`crate::shared::CommandOutput`].

pub mod types;

mod client;
pub mod create;
pub mod delete;
mod edit;
mod edit_apply;
mod list;
mod logs;
mod logs_db;
pub mod logs_disk;
mod message;
mod message_request;
mod message_streaming;
mod registry;
mod run;
pub mod shared;
pub mod show;
mod status;
mod task;
mod tools;
mod tools_mcp;
mod validate;

use anyhow::{Context, Result};
use clap::Subcommand;

use crate::context::CommandContext;
use crate::shared::render_result;

#[derive(Debug, Subcommand)]
pub enum AgentsCommands {
    #[command(about = "List configured agents")]
    List(list::ListArgs),

    #[command(about = "Display agent configuration")]
    Show(show::ShowArgs),

    #[command(about = "Check agent configs for errors")]
    Validate(validate::ValidateArgs),

    #[command(about = "Create new agent")]
    Create(create::CreateArgs),

    #[command(about = "Edit agent configuration")]
    Edit(edit::EditArgs),

    #[command(about = "Delete an agent")]
    Delete(delete::DeleteArgs),

    #[command(about = "Show agent process status")]
    Status(status::StatusArgs),

    #[command(about = "View agent logs")]
    Logs(logs::LogsArgs),

    #[command(about = "Get running agents from gateway registry (A2A discovery)")]
    Registry(registry::RegistryArgs),

    #[command(about = "Send a message to an agent via A2A protocol")]
    Message(message::MessageArgs),

    #[command(about = "Get task details and response from an agent")]
    Task(task::TaskArgs),

    #[command(about = "List MCP tools available to an agent")]
    Tools(tools::ToolsArgs),

    #[command(about = "Run an agent server directly (bypasses orchestration)")]
    Run(run::RunArgs),
}

pub async fn execute(command: AgentsCommands, ctx: &CommandContext) -> Result<()> {
    let result = match command {
        AgentsCommands::List(args) => {
            list::execute(args, &ctx.cli).context("Failed to list agents")?
        },
        AgentsCommands::Show(args) => {
            show::execute(args, ctx.prompter(), &ctx.cli).context("Failed to show agent")?
        },
        AgentsCommands::Validate(args) => {
            validate::execute(&args, &ctx.cli).context("Failed to validate agents")?
        },
        AgentsCommands::Create(args) => {
            create::execute(args, ctx.prompter(), &ctx.cli).context("Failed to create agent")?
        },
        AgentsCommands::Edit(args) => {
            edit::execute(&args, ctx.prompter(), &ctx.cli).context("Failed to edit agent")?
        },
        AgentsCommands::Delete(args) => delete::execute(args, ctx.prompter(), &ctx.cli)
            .await
            .context("Failed to delete agent")?,
        AgentsCommands::Status(args) => status::execute(args, &ctx.cli)
            .await
            .context("Failed to get agent status")?,
        AgentsCommands::Logs(args) => logs::execute(args, ctx.prompter(), &ctx.cli)
            .await
            .context("Failed to get agent logs")?,
        AgentsCommands::Registry(args) => registry::execute(args, &ctx.cli)
            .await
            .context("Failed to get agent registry")?,
        AgentsCommands::Message(args) => message::execute(args, ctx)
            .await
            .context("Failed to send message to agent")?,
        AgentsCommands::Task(args) => task::execute(args, ctx)
            .await
            .context("Failed to get task details")?,
        AgentsCommands::Tools(args) => tools::execute(args, ctx)
            .await
            .context("Failed to list agent tools")?,
        AgentsCommands::Run(args) => {
            return run::execute(args).await.context("Failed to run agent");
        },
    };
    render_result(&result, &ctx.cli);
    Ok(())
}