folderbase-cli 0.6.1

Folderbase command-line tools for agent-ready local-first folders.
use std::{
    io::{Read, Write},
    path::PathBuf,
};

use folderbase_core::{
    ChangeSetApplyOutcome, ChangeSetAssessmentOutcome, ChangeSetEnvelope, ChangeSetError,
    CheckoutRequest, MAX_CHANGE_SET_BYTES, apply_change_set, assess_change_set,
    checkout_change_set_projection, propose_change_set,
};
use serde::Serialize;

const EXIT_SUCCESS: u8 = 0;
const EXIT_ATTENTION: u8 = 1;
const EXIT_OPERATIONAL_ERROR: u8 = 2;

pub(crate) enum ChangeSetOperation {
    Checkout { root: PathBuf, destination: PathBuf },
    Propose { checkout: PathBuf, staging: PathBuf },
    Assess { root: PathBuf, staging: PathBuf },
    Apply { root: PathBuf, staging: PathBuf },
}

pub(crate) struct ChangeSetTransport {
    pub(crate) exit_code: u8,
    pub(crate) stdout: Vec<u8>,
    pub(crate) stderr: Vec<u8>,
}

pub(crate) fn execute(operation: ChangeSetOperation, stdin: impl Read) -> ChangeSetTransport {
    match operation {
        ChangeSetOperation::Checkout { root, destination } => {
            let request = match read_json_bounded::<CheckoutRequest>(stdin) {
                Ok(request) => request,
                Err(message) => {
                    return error_transport("invalid_checkout_request", message);
                }
            };
            match checkout_change_set_projection(root, destination, request) {
                Ok(result) => success_transport(&result),
                Err(error) => core_error_transport(error),
            }
        }
        ChangeSetOperation::Propose { checkout, staging } => {
            match propose_change_set(checkout, staging) {
                Ok(result) => success_transport(&result),
                Err(error) => core_error_transport(error),
            }
        }
        ChangeSetOperation::Assess { root, staging } => {
            let envelope = match read_json_bounded::<ChangeSetEnvelope>(stdin) {
                Ok(envelope) => envelope,
                Err(message) => return error_transport("invalid_change_set_input", message),
            };
            match assess_change_set(root, staging, envelope) {
                Ok(ChangeSetAssessmentOutcome::Clean(result)) => success_transport(&result),
                Ok(ChangeSetAssessmentOutcome::Attention(result)) => attention_transport(&result),
                Err(error) => core_error_transport(error),
            }
        }
        ChangeSetOperation::Apply { root, staging } => {
            let envelope = match read_json_bounded::<ChangeSetEnvelope>(stdin) {
                Ok(envelope) => envelope,
                Err(message) => return error_transport("invalid_change_set_input", message),
            };
            match apply_change_set(root, staging, envelope) {
                Ok(ChangeSetApplyOutcome::Applied(result)) => success_transport(&result),
                Ok(ChangeSetApplyOutcome::Attention(result)) => attention_transport(&result),
                Err(error) => core_error_transport(error),
            }
        }
    }
}

pub(crate) fn invalid_invocation(message: String) -> ChangeSetTransport {
    error_transport("invalid_change_set_input", message)
}

fn read_json_bounded<T: for<'de> serde::Deserialize<'de>>(
    mut reader: impl Read,
) -> Result<T, String> {
    let mut bytes = Vec::new();
    reader
        .by_ref()
        .take(MAX_CHANGE_SET_BYTES + 1)
        .read_to_end(&mut bytes)
        .map_err(|error| format!("failed to read stdin: {error}"))?;
    if bytes.len() as u64 > MAX_CHANGE_SET_BYTES {
        return Err("stdin exceeds the 8 MiB Change Set bound".to_owned());
    }
    serde_json::from_slice(&bytes).map_err(|error| format!("stdin is not valid JSON: {error}"))
}

fn success_transport(value: &impl Serialize) -> ChangeSetTransport {
    match encode(value) {
        Ok(stdout) => ChangeSetTransport {
            exit_code: EXIT_SUCCESS,
            stdout,
            stderr: Vec::new(),
        },
        Err(message) => error_transport("change_set_operational_error", message),
    }
}

fn attention_transport(value: &impl Serialize) -> ChangeSetTransport {
    match encode(value) {
        Ok(stdout) => ChangeSetTransport {
            exit_code: EXIT_ATTENTION,
            stdout,
            stderr: Vec::new(),
        },
        Err(message) => error_transport("change_set_operational_error", message),
    }
}

fn core_error_transport(error: ChangeSetError) -> ChangeSetTransport {
    error_transport(error.code(), error.message())
}

fn error_transport(code: &'static str, message: String) -> ChangeSetTransport {
    let value = serde_json::json!({
        "format": "folderbase-change-set-error-v1",
        "error": {
            "code": code,
            "message": message,
        }
    });
    let stderr = encode(&value).unwrap_or_else(|_| {
        b"{\"format\":\"folderbase-change-set-error-v1\",\"error\":{\"code\":\"change_set_operational_error\",\"message\":\"failed to encode error\"}}\n".to_vec()
    });
    ChangeSetTransport {
        exit_code: EXIT_OPERATIONAL_ERROR,
        stdout: Vec::new(),
        stderr,
    }
}

fn encode(value: &impl Serialize) -> Result<Vec<u8>, String> {
    let mut encoded = Vec::new();
    serde_json::to_writer(&mut encoded, value).map_err(|error| error.to_string())?;
    encoded
        .write_all(b"\n")
        .map_err(|error| error.to_string())?;
    if encoded.len() as u64 > MAX_CHANGE_SET_BYTES {
        return Err("encoded Change Set output exceeds 8 MiB".to_owned());
    }
    Ok(encoded)
}