adbrent 0.4.2

One Android device per AI agent: an adb device lock for parallel Claude Code and other coding-agent sessions
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Process inspection: who is asking, and is a renter still alive.

#[derive(Clone, Debug)]
pub struct Proc {
    pub pid: i32,
    pub ppid: i32,
    pub name: String,
    /// Start time, used with the pid so a recycled pid is not mistaken for the renter.
    pub start: u64,
}

#[cfg(target_os = "macos")]
pub fn info(pid: i32) -> Option<Proc> {
    let mut bi: libc::proc_bsdinfo = unsafe { std::mem::zeroed() };
    let size = std::mem::size_of::<libc::proc_bsdinfo>() as libc::c_int;
    let n = unsafe {
        libc::proc_pidinfo(
            pid,
            libc::PROC_PIDTBSDINFO,
            0,
            &mut bi as *mut _ as *mut libc::c_void,
            size,
        )
    };
    if n != size {
        return None;
    }
    let cstr = |b: &[libc::c_char]| {
        let bytes: Vec<u8> = b
            .iter()
            .take_while(|&&c| c != 0)
            .map(|&c| c as u8)
            .collect();
        String::from_utf8_lossy(&bytes).into_owned()
    };
    // pbi_comm is the command name (`claude`); pbi_name can be the binary's
    // file name, which for a versioned install is just a version number.
    let mut name = cstr(&bi.pbi_comm);
    if name.is_empty() {
        name = cstr(&bi.pbi_name);
    }
    Some(Proc {
        pid,
        ppid: bi.pbi_ppid as i32,
        name,
        start: bi
            .pbi_start_tvsec
            .wrapping_mul(1_000_000)
            .wrapping_add(bi.pbi_start_tvusec),
    })
}

#[cfg(target_os = "linux")]
pub fn info(pid: i32) -> Option<Proc> {
    let stat = std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
    let open = stat.find('(')?;
    let close = stat.rfind(')')?;
    let name = stat.get(open + 1..close)?.to_string();
    // After the name: state ppid pgrp ... starttime is the 20th field here.
    let rest: Vec<&str> = stat.get(close + 1..)?.split_whitespace().collect();
    Some(Proc {
        pid,
        ppid: rest.get(1)?.parse().ok()?,
        name,
        start: rest.get(19)?.parse().ok()?,
    })
}

#[cfg(not(any(target_os = "macos", target_os = "linux")))]
pub fn info(_pid: i32) -> Option<Proc> {
    None
}

pub fn alive(pid: i32, start: u64) -> bool {
    info(pid).is_some_and(|p| p.start == start)
}

/// Agent harnesses we recognise by process name. Anything else falls back to
/// the nearest ancestor that is not a shell or a command wrapper.
const AGENTS: &[&str] = &[
    "claude",
    "codex",
    "opencode",
    "gemini",
    "aider",
    "goose",
    "amp",
    "cursor-agent",
    "crush",
    "droid",
    "qwen",
    "grok",
    "copilot",
];
const WRAPPERS: &[&str] = &[
    "sh", "bash", "zsh", "fish", "dash", "ksh", "csh", "tcsh", "env", "sudo", "nohup", "timeout",
    "time", "xargs", "adb", "adbrent",
];

/// Path of a process's executable, when the OS will tell us.
#[cfg(target_os = "macos")]
fn exe(pid: i32) -> Option<String> {
    let mut buf = [0u8; 4096];
    let n =
        unsafe { libc::proc_pidpath(pid, buf.as_mut_ptr() as *mut libc::c_void, buf.len() as u32) };
    (n > 0).then(|| String::from_utf8_lossy(&buf[..n as usize]).into_owned())
}

#[cfg(not(target_os = "macos"))]
fn exe(pid: i32) -> Option<String> {
    Some(
        std::fs::read_link(format!("/proc/{pid}/exe"))
            .ok()?
            .to_string_lossy()
            .into_owned(),
    )
}

/// The agent a process is, if it is one. The command name is checked first,
/// then the executable path: a versioned install runs as `.../claude/versions/2.1.3`.
fn agent(p: &Proc) -> Option<&'static str> {
    let is = |s: &str| {
        AGENTS
            .iter()
            .copied()
            .find(|a| s.trim_start_matches('-').eq_ignore_ascii_case(a))
    };
    is(&p.name).or_else(|| exe(p.pid)?.split('/').find_map(is))
}

/// The long-lived process a rental belongs to: the agent that (indirectly)
/// started us. The rental lasts exactly as long as that process does.
pub fn anchor() -> Option<Proc> {
    let mut cur = info(unsafe { libc::getppid() })?;
    let mut fallback: Option<Proc> = None;
    loop {
        if let Some(name) = agent(&cur) {
            cur.name = name.to_string();
            return Some(cur);
        }
        let name = cur.name.trim_start_matches('-').to_ascii_lowercase();
        if fallback.is_none() && !WRAPPERS.contains(&name.as_str()) {
            fallback = Some(cur.clone());
        }
        if cur.ppid <= 1 {
            break;
        }
        match info(cur.ppid) {
            Some(p) => cur = p,
            None => break,
        }
    }
    fallback.or(Some(cur))
}