incode 0.30.26038

InCode - MCP server for LLDB debugging automation
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

use thiserror::Error;

pub type IncodeResult<T> = Result<T, IncodeError>;

#[derive(Error, Debug)]
pub enum IncodeError {
    #[error("LLDB initialization failed: {0}")]
    LldbInitialization(String),

    #[error("LLDB operation failed: {0}")]
    LldbOperation(String),

    #[error("Process not found or not debuggable: {0}")]
    ProcessNotFound(String),

    #[error("Invalid memory address: 0x{address:x}")]
    InvalidMemoryAddress { address: u64 },

    #[error("Breakpoint operation failed: {0}")]
    BreakpointError(String),

    #[error("Thread operation failed: {0}")]
    ThreadError(String),

    #[error("Frame operation failed: {0}")]
    FrameError(String),

    #[error("Expression evaluation failed: {0}")]
    ExpressionError(String),

    #[error("MCP protocol error: {0}")]
    McpProtocol(String),

    #[error("Session management error: {0}")]
    SessionError(String),

    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    #[error("JSON serialization error: {0}")]
    Json(#[from] serde_json::Error),

    #[error("Invalid configuration: {0}")]
    Configuration(String),

    #[error("Timeout error: operation took too long")]
    Timeout,

    #[error("Not implemented: {0}")]
    NotImplemented(String),
    
    #[error("Invalid parameter: {0}")]
    InvalidParameter(String),
    
    #[error("Process error: {0}")]
    ProcessError(String),
}

impl IncodeError {
    pub fn lldb_init<S: Into<String>>(msg: S) -> Self {
        Self::LldbInitialization(msg.into())
    }

    pub fn lldb_op<S: Into<String>>(msg: S) -> Self {
        Self::LldbOperation(msg.into())
    }

    pub fn process_not_found<S: Into<String>>(msg: S) -> Self {
        Self::ProcessNotFound(msg.into())
    }

    pub fn invalid_address(address: u64) -> Self {
        Self::InvalidMemoryAddress { address }
    }

    pub fn breakpoint<S: Into<String>>(msg: S) -> Self {
        Self::BreakpointError(msg.into())
    }

    pub fn thread<S: Into<String>>(msg: S) -> Self {
        Self::ThreadError(msg.into())
    }

    pub fn frame<S: Into<String>>(msg: S) -> Self {
        Self::FrameError(msg.into())
    }

    pub fn expression<S: Into<String>>(msg: S) -> Self {
        Self::ExpressionError(msg.into())
    }

    pub fn mcp<S: Into<String>>(msg: S) -> Self {
        Self::McpProtocol(msg.into())
    }

    pub fn session<S: Into<String>>(msg: S) -> Self {
        Self::SessionError(msg.into())
    }

    pub fn config<S: Into<String>>(msg: S) -> Self {
        Self::Configuration(msg.into())
    }

    pub fn not_implemented<S: Into<String>>(feature: S) -> Self {
        Self::NotImplemented(feature.into())
    }
    
    pub fn invalid_parameter<S: Into<String>>(msg: S) -> Self {
        Self::InvalidParameter(msg.into())
    }
    
    pub fn process<S: Into<String>>(msg: S) -> Self {
        Self::ProcessError(msg.into())
    }
    
    pub fn no_process() -> Self {
        Self::ProcessError("No process attached".to_string())
    }
}