agentmux 0.1.0

Multi-agent coordination runtime with inter-agent messaging across CLI, MCP, tmux, and ACP.
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

//! Error types for runtime bootstrap and path resolution.

use std::{
    error::Error,
    fmt::{Display, Formatter},
    io,
    path::PathBuf,
    time::Duration,
};

/// Runtime failure emitted by bootstrap and filesystem helpers.
#[derive(Debug)]
pub enum RuntimeError {
    HomeDirectoryUnavailable,
    InvalidArgument {
        argument: String,
        message: String,
    },
    Validation {
        code: String,
        message: String,
    },
    InvalidBundleName {
        bundle_name: String,
    },
    RelayAutostartDisabled {
        relay_socket: PathBuf,
    },
    RelayStartupTimeout {
        relay_socket: PathBuf,
        startup_timeout: Duration,
    },
    RelaySpawnFailure {
        command: PathBuf,
        source: io::Error,
    },
    SecurityForeignOwned {
        path: PathBuf,
        expected_uid: u32,
        actual_uid: u32,
    },
    Io {
        context: String,
        source: io::Error,
    },
}

impl RuntimeError {
    pub fn io(context: impl Into<String>, source: io::Error) -> Self {
        Self::Io {
            context: context.into(),
            source,
        }
    }

    pub fn validation(code: impl Into<String>, message: impl Into<String>) -> Self {
        Self::Validation {
            code: code.into(),
            message: message.into(),
        }
    }
}

impl Display for RuntimeError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::HomeDirectoryUnavailable => {
                write!(formatter, "home directory is unavailable; set HOME")
            }
            Self::InvalidArgument { argument, message } => {
                write!(formatter, "invalid argument {argument}: {message}")
            }
            Self::Validation { code, message } => {
                write!(formatter, "{code}: {message}")
            }
            Self::InvalidBundleName { bundle_name } => {
                write!(formatter, "invalid bundle name '{bundle_name}'")
            }
            Self::RelayAutostartDisabled { relay_socket } => write!(
                formatter,
                "relay unavailable at {}; start agentmux host relay with matching --state-directory",
                relay_socket.display()
            ),
            Self::RelayStartupTimeout {
                relay_socket,
                startup_timeout,
            } => write!(
                formatter,
                "relay startup timed out after {}ms while waiting for {}",
                startup_timeout.as_millis(),
                relay_socket.display()
            ),
            Self::RelaySpawnFailure { command, .. } => write!(
                formatter,
                "failed to spawn relay command {}",
                command.display()
            ),
            Self::SecurityForeignOwned {
                path,
                expected_uid,
                actual_uid,
            } => write!(
                formatter,
                "runtime artifact {} is owned by uid {}, expected uid {}",
                path.display(),
                actual_uid,
                expected_uid
            ),
            Self::Io { context, source } => {
                write!(formatter, "{context}: {source}")
            }
        }
    }
}

impl Error for RuntimeError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Io { source, .. } | Self::RelaySpawnFailure { source, .. } => Some(source),
            _ => None,
        }
    }
}