mail4agent-messenger-shell 0.4.6

Client shell that opens the sealed messenger store for one session.
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

//! Stand-ins for wake adapters whose feature is off (`wake-codex`, `wake-kimi`, `wake-claude`,
//! `wake-spawn`). The real modules are not compiled; these keep the chain planner and the adapter
//! table type-correct, and every attempt reports why nothing was delivered.

#![allow(dead_code)]

use std::path::PathBuf;

use super::{ProviderKind, ProviderSession, SessionKind, WakeAdapter, WakeError, WakeLetter, WakeOutcome};

macro_rules! off_adapter {
    ($ty:ident, $kind:expr, $feature:literal) => {
        pub struct $ty;
        impl WakeAdapter for $ty {
            fn kind(&self) -> SessionKind {
                $kind
            }
            fn probe(&self, _: &ProviderSession) -> Result<(), WakeError> {
                Err(WakeError::Unavailable(concat!("this build was made without feature ", $feature).into()))
            }
            fn wake(&mut self, s: &ProviderSession, _: &WakeLetter<'_>) -> Result<WakeOutcome, WakeError> {
                self.probe(s).map(|()| WakeOutcome::Delivered)
            }
        }
    };
}

pub mod codex {
    use super::*;
    #[derive(Clone, Debug)]
    pub struct CodexEndpoint;
    impl CodexEndpoint {
        pub fn parse(_: &str) -> Option<Self> {
            None
        }
        pub fn from_env() -> Option<Self> {
            None
        }
    }
    off_adapter!(CodexAppServerAdapter, SessionKind::local(ProviderKind::Codex), "wake-codex");
    impl CodexAppServerAdapter {
        pub fn new(_: Option<CodexEndpoint>) -> Self {
            Self
        }
    }
}

pub mod kimi {
    use super::*;
    off_adapter!(KimiServerAdapter, SessionKind::local(ProviderKind::KimiCode), "wake-kimi");
    impl KimiServerAdapter {
        pub fn new(_: Option<String>, _: Option<String>) -> Self {
            Self
        }
        pub fn from_env() -> Self {
            Self
        }
        pub fn is_configured(&self) -> bool {
            false
        }
        pub fn into_parts(self) -> (Option<String>, Option<String>) {
            (None, None)
        }
    }
    pub fn discover_local_server(_: Option<&std::path::Path>) -> Option<KimiServerAdapter> {
        None
    }
}

pub mod claude_channel {
    use super::*;
    off_adapter!(ClaudeChannelAdapter, SessionKind::local(ProviderKind::ClaudeCode), "wake-claude");
    impl ClaudeChannelAdapter {
        pub fn new(_: Option<PathBuf>) -> Self {
            Self
        }
    }
}

pub mod spawn {
    use super::*;
    pub const CODEX_CLOUD_ENV_ENV: &str = "M4A_CODEX_CLOUD_ENV";
    pub fn bin_env(_: ProviderKind) -> &'static str {
        "M4A_SPAWN_PROGRAM_UNAVAILABLE"
    }
    off_adapter!(ResumeSpawnAdapter, SessionKind::local(ProviderKind::Grok), "wake-spawn");
    impl ResumeSpawnAdapter {
        pub fn new(_: SessionKind, _: Option<PathBuf>, _: Option<String>) -> Self {
            Self
        }
        pub fn from_env(_: SessionKind) -> Self {
            Self
        }
    }
}