feat(rola-bucket): add bucket bind managementHEADmaster

Implement bucket bind CRUD operations and config loading, along with
CLI integration for listing, setting, and removing bucket bindings.

3 files changed, 93 insertions, 2 deletions

diff --git a/rola-cli/src/error/io.rs b/rola-cli/src/error/io.rs
index d65b765..7f31824 100644
--- a/rola-cli/src/error/io.rs
+++ b/rola-cli/src/error/io.rs
@@ -3,6 +3,7 @@ use mingling::{
     macros::{r_println, renderer},
     res::ResExitCode,
 };
+use serde::Serialize;
 
 use crate::locale::errors::I18nIoError;
 
@@ -46,7 +47,7 @@ pub const EC_IOERR_UNEXPECTED_EOF: i32 = 2536;
 pub const EC_IOERR_OUT_OF_MEMORY: i32 = 2537;
 pub const EC_IOERR_OTHER: i32 = 2538;
 
-#[derive(Default, Groupped)]
+#[derive(Default, Serialize, Groupped)]
 pub enum ErrorIo {
     #[default]
     /// DONT USE IT: This variant is only used to provide a Default derive for ErrorIo
@@ -54,7 +55,14 @@ pub enum ErrorIo {
     /// In normal creation flow, you should directly use ErrorIo::from(/* std::io::Error */)
     DontUse,
 
-    Error(std::io::Error),
+    Error(#[serde(serialize_with = "serialize_io_error")] std::io::Error),
+}
+
+fn serialize_io_error<S: serde::Serializer>(
+    err: &std::io::Error,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    serializer.serialize_str(&format!("{:?}", err))
 }
 
 #[renderer]
diff --git a/rola-cli/src/error/require_overwrite.rs b/rola-cli/src/error/require_overwrite.rs
new file mode 100644
index 0000000..c84dcb1
--- /dev/null
+++ b/rola-cli/src/error/require_overwrite.rs
@@ -0,0 +1,19 @@
+use mingling::{
+    macros::{pack_err, r_println, renderer},
+    res::ResExitCode,
+};
+
+use crate::{locale, output::display::markdown};
+
+pub const EC_REQUIRE_OVERWRITE: i32 = 1001;
+
+pack_err!(ErrorRequireOverwrite);
+
+#[renderer]
+pub fn render_error_require_overwrite(_err: ErrorRequireOverwrite, ec: &mut ResExitCode) {
+    r_println!(
+        "{}",
+        markdown(locale::errors::Common::require_overwrite().trim())
+    );
+    ec.exit_code = EC_REQUIRE_OVERWRITE;
+}
diff --git a/rola-cli/src/error/space.rs b/rola-cli/src/error/space.rs
new file mode 100644
index 0000000..fb0a560
--- /dev/null
+++ b/rola-cli/src/error/space.rs
@@ -0,0 +1,64 @@
+use mingling::{
+    Groupped,
+    macros::{chain, r_println, renderer},
+    res::ResExitCode,
+};
+use serde::Serialize;
+use space_system::SpaceError;
+
+use crate::{Next, error::ErrorIo, locale::errors::I18nSpaceError};
+
+pub const EC_SPACE_NOT_FOUND: i32 = 2600;
+pub const EC_SPACE_PATH_FORMAT: i32 = 2601;
+pub const EC_SPACE_REQUIRE_EMPTY_DIR: i32 = 2602;
+pub const EC_SPACE_CONFIG_ALREADY_EXIST: i32 = 2603;
+
+#[derive(Serialize, Groupped)]
+pub struct ErrorSpace {
+    pub error: SpaceError,
+}
+
+#[chain]
+pub fn handle_error_space(err: ErrorSpace) -> Next {
+    match err.error {
+        // Forward to ErrorIo
+        SpaceError::Io(error) => ErrorIo::from(error).to_render(),
+
+        _ => err.to_render(),
+    }
+}
+
+#[renderer]
+pub fn render_error_space(err: ErrorSpace, ec: &mut ResExitCode) {
+    match &err.error {
+        SpaceError::SpaceNotFound => {
+            r_println!("{}", I18nSpaceError::space_not_found().trim());
+            ec.exit_code = EC_SPACE_NOT_FOUND;
+        }
+        SpaceError::PathFormatError(_) => {
+            r_println!("{}", I18nSpaceError::path_format().trim());
+            ec.exit_code = EC_SPACE_PATH_FORMAT;
+        }
+        SpaceError::RequireEmptyDirectory => {
+            r_println!("{}", I18nSpaceError::require_empty_directory().trim());
+            ec.exit_code = EC_SPACE_REQUIRE_EMPTY_DIR;
+        }
+        SpaceError::ConfigFileAlreadyExist => {
+            r_println!("{}", I18nSpaceError::config_file_already_exist().trim());
+            ec.exit_code = EC_SPACE_CONFIG_ALREADY_EXIST;
+        }
+        SpaceError::Io(_) => {
+            // Forwarded to ErrorIo via handle_error_space chain
+        }
+        SpaceError::Other(_) => {
+            r_println!("{}", I18nSpaceError::space_not_found().trim());
+            ec.exit_code = EC_SPACE_NOT_FOUND;
+        }
+    }
+}
+
+impl From<SpaceError> for ErrorSpace {
+    fn from(error: SpaceError) -> Self {
+        Self { error }
+    }
+}