clawshell 0.1.1

A security privileged process for the OpenClaw ecosystem.
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

use std::path::{Path, PathBuf};

use thiserror::Error;

use crate::migration::core::{
    AmbiguityResolutionError, AmbiguityResolver, ConfigVersion, ConfigVersionParseError,
};

#[derive(Debug, Clone, Default)]
pub struct TargetMigrationOutput {
    pub content: String,
    pub applied_steps: Vec<String>,
    pub warnings: Vec<String>,
}

#[derive(Debug, Error)]
pub enum TargetError {
    #[error("failed to parse TOML: {0}")]
    TomlParse(#[from] toml::de::Error),

    #[error("failed to serialize TOML: {0}")]
    TomlSerialize(#[from] toml::ser::Error),

    #[error("configuration must be a top-level TOML table")]
    TopLevelTableExpected,

    #[error("top-level 'version' must be a string, got {found}")]
    VersionMustBeString { found: String },

    #[error("invalid top-level 'version' value '{value}': {source}")]
    InvalidVersionValue {
        value: String,
        #[source]
        source: ConfigVersionParseError,
    },

    #[error("configuration migration required: missing top-level 'version' (expected {expected})")]
    MigrationRequiredMissingVersion {
        expected: ConfigVersion,
        path: PathBuf,
    },

    #[error(
        "configuration migration required: found version {found} but current version is {expected}"
    )]
    MigrationRequiredVersionMismatch {
        found: ConfigVersion,
        expected: ConfigVersion,
        path: PathBuf,
    },

    #[error("migration aborted: source version {from} is newer than target {to}")]
    DowngradeAborted {
        from: ConfigVersion,
        to: ConfigVersion,
    },

    #[error("migration aborted: {reason}")]
    MigrationAborted { reason: String },

    #[error("invalid configuration after migration: {details}")]
    Validation { details: String },

    #[error(transparent)]
    Ambiguity(#[from] AmbiguityResolutionError),
}

pub trait MigrationTarget: std::fmt::Debug {
    fn name(&self) -> &'static str;
    fn path(&self) -> &Path;

    fn detect_version(&self, content: &str) -> Result<Option<ConfigVersion>, TargetError>;

    fn migrate(
        &self,
        content: &str,
        from: &ConfigVersion,
        to: &ConfigVersion,
        resolver: &mut dyn AmbiguityResolver,
    ) -> Result<TargetMigrationOutput, TargetError>;

    fn validate(&self, content: &str) -> Result<(), TargetError>;
}