degenbot-cli-core 0.6.0-alpha.14

Command semantics + the database command arms for the degenbot console (ADR-051 D1) - pyo3-free and clap-free.
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

//! The `fleet` command arms (ADR-051 D6;).
//!
//! Ports `cli/fleet.py`: both verbs are thin clients of a LIVE bot's
//! `OperatorServer` over the JSON-lines wire protocol in
//! [`crate::operator`]. The socket is resolved through the same cascade the
//! rest of the console uses (`--socket` > `DEGENBOT_OPERATOR_SOCKET` > the
//! `~/.config/degenbot/operator.sock` plugin default); no local config or
//! database work happens here.
//!
//! - `fleet posture show` sends `get_fleet_posture` and renders the echoed
//!   effective policy as one sorted JSON line.
//! - `fleet posture set` is a PARTIAL patch: it validates wire hygiene
//!   (unknown key / empty patch, in [`crate::operator::validate_posture_patch`])
//!   BEFORE the socket is touched, sends `set_fleet_posture`, and renders the
//!   echoed effective policy. Value validation stays server-side.

use crate::context::CliContext;
use crate::error::CliError;
use crate::operator::{
    render_json_sorted, resolve_socket, send_request, validate_posture_patch, PosturePatchEntry,
    WireRequest, WireResponse,
};
use crate::prompt::PromptPlan;
use crate::report::FleetReport;

/// The `fleet` command group.
#[derive(Debug, Clone, PartialEq)]
pub enum FleetCommand {
    /// `fleet posture show`: read the live cordon posture.
    PostureShow {
        /// The operator socket path override (`--socket`).
        socket: Option<String>,
    },
    /// `fleet posture set`: re-tune a subset of the six cordon thresholds.
    PostureSet {
        /// The operator socket path override (`--socket`).
        socket: Option<String>,
        /// The partial patch (at least one entry; known keys only).
        patch: Vec<PosturePatchEntry>,
    },
}

impl FleetCommand {
    /// Neither fleet arm prompts.
    #[must_use]
    pub const fn prompt_plan(&self, _ctx: &CliContext<'_>) -> PromptPlan {
        PromptPlan::None
    }
}

/// Execute a `fleet` command.
///
/// # Errors
///
/// [`CliError::OperatorHygiene`] for a client-side wire-hygiene refusal (an
/// empty or unknown-key patch, raised before any socket work);
/// [`CliError::OperatorRefused`] for a `{"ok": false}` host reply;
/// [`CliError::OperatorProtocol`] for an unreachable socket or a malformed
/// response.
pub(crate) fn execute(
    command: &FleetCommand,
    ctx: &CliContext<'_>,
) -> Result<FleetReport, CliError> {
    match command {
        FleetCommand::PostureShow { socket } => Ok(FleetReport::Posture {
            effective: call(ctx, socket.as_deref(), &WireRequest::GetFleetPosture)?,
        }),
        FleetCommand::PostureSet { socket, patch } => {
            validate_posture_patch(patch)?;
            let request = WireRequest::SetFleetPosture {
                patch: patch.clone(),
            };
            Ok(FleetReport::Posture {
                effective: call(ctx, socket.as_deref(), &request)?,
            })
        }
    }
}

/// Send one fleet request and render the echoed effective policy.
fn call(
    ctx: &CliContext<'_>,
    socket: Option<&str>,
    request: &WireRequest,
) -> Result<String, CliError> {
    let socket = resolve_socket(ctx.env(), socket);
    match send_request(&socket, request)? {
        WireResponse::Ok { effective, .. } => Ok(render_json_sorted(effective.as_ref())),
        WireResponse::Err { error } => Err(CliError::OperatorRefused(error)),
    }
}