1use std::path::{Path, PathBuf};
27
28use regex::bytes::Regex;
29
30const TRAILER: &[u8] = b"\n---- Bun! ----\n";
31const OFFSETS_SIZE: usize = 32;
32const ENTRY_SIZE: usize = 52;
33const BYTECODE_PTR: usize = 24;
35const MODULE_MARKER: &[u8] = b"\"tengu_rustling_blossom\"";
37
38#[cfg(target_os = "macos")]
40const CODESIGN_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(60);
41
42#[derive(Debug, thiserror::Error)]
44#[non_exhaustive]
45pub enum CodeModeError {
46 #[error("not a Bun standalone binary: {0}")]
49 NotBunBinary(&'static str),
50 #[error("Code Mode module not found in the CLI binary")]
52 ModuleNotFound,
53 #[error("patch anchor `{name}` has an invalid pattern: {source}")]
55 PatternInvalid {
56 name: &'static str,
58 #[source]
60 source: regex::Error,
61 },
62 #[error("patch anchor `{name}` found {found} times (expected 1); this CLI version is not supported")]
64 AnchorCount {
65 name: &'static str,
67 found: usize,
69 },
70 #[error(
72 "patch anchor `{name}` matched {matched} bytes, fewer than its {replacement}-byte replacement; \
73 this CLI version is not supported"
74 )]
75 ReplacementTooShort {
76 name: &'static str,
78 matched: usize,
80 replacement: usize,
82 },
83 #[error("io: {0}")]
86 Io(#[from] std::io::Error),
87 #[error("re-signing the patched CLI failed: {0}")]
89 Sign(String),
90 #[error("`settings` must be a JSON object (with an object `env`) to add the Code Mode env var")]
92 Settings,
93 #[error("Code Mode is supported on macOS and Linux only")]
95 UnsupportedPlatform,
96}
97
98pub fn patch(binary: &[u8]) -> Result<Vec<u8>, CodeModeError> {
102 let mut out = binary.to_vec();
103 let (entry, contents) = find_module(&out)?;
104
105 let module = &out[contents.clone()];
106 let gate_var = unique_match(module, "gate variable", r#"var ([\w$]+)="tengu_rustling_blossom""#)?;
107 let gate_var = regex::escape(&String::from_utf8_lossy(&module[gate_var]));
108
109 let edits: [(&'static str, String, &[u8]); 3] = [
110 ("eligibility", r#"(?:\{)(if\(![\w$]+\(\)\)return"runtime";)"#.into(), b"return;"),
111 (
112 "caveats",
113 r"([\w$]+\.codeModeCaveatsAcceptedV1===!0&&[\w$]+\.codeModeAutoModeCaveatAcceptedV1===!0)".into(),
114 b"!0",
115 ),
116 ("gate", format!(r"(return [\w$]+\({gate_var},!0\)!==!0)"), b"return!1"),
117 ];
118 for (name, pattern, replacement) in edits {
119 let span = unique_match(&out[contents.clone()], name, &pattern)?;
120 if span.len() < replacement.len() {
121 return Err(CodeModeError::ReplacementTooShort { name, matched: span.len(), replacement: replacement.len() });
122 }
123 let start = contents.start + span.start;
124 overwrite_padded(&mut out[start..start + span.len()], replacement);
125 }
126
127 out.get_mut(entry + BYTECODE_PTR..entry + BYTECODE_PTR + 8)
129 .ok_or(CodeModeError::NotBunBinary("module table"))?
130 .fill(0);
131 Ok(out)
132}
133
134fn find_module(data: &[u8]) -> Result<(usize, std::ops::Range<usize>), CodeModeError> {
136 let trailer = rfind(data, TRAILER).ok_or(CodeModeError::NotBunBinary("no trailer"))?;
137 let offsets = trailer.checked_sub(OFFSETS_SIZE).ok_or(CodeModeError::NotBunBinary("short file"))?;
138 let byte_count = usize::try_from(read_u64(data, offsets)?).map_err(|_| CodeModeError::NotBunBinary("size"))?;
139 let modules_off = read_u32(data, offsets + 8)?;
140 let modules_len = read_u32(data, offsets + 12)?;
141 let base = offsets.checked_sub(byte_count).ok_or(CodeModeError::NotBunBinary("graph size"))?;
142
143 for i in 0..modules_len / ENTRY_SIZE {
144 let entry = base + modules_off + i * ENTRY_SIZE;
145 let start = base + read_u32(data, entry + 8)?;
146 let end = start + read_u32(data, entry + 12)?;
147 let contents = data.get(start..end).ok_or(CodeModeError::NotBunBinary("module bounds"))?;
148 if contents.windows(MODULE_MARKER.len()).any(|w| w == MODULE_MARKER) {
149 return Ok((entry, start..end));
150 }
151 }
152 Err(CodeModeError::ModuleNotFound)
153}
154
155fn unique_match(haystack: &[u8], name: &'static str, pattern: &str) -> Result<std::ops::Range<usize>, CodeModeError> {
157 let re = Regex::new(pattern).map_err(|source| CodeModeError::PatternInvalid { name, source })?;
158 let found: Vec<_> = re.captures_iter(haystack).filter_map(|c| c.get(1)).map(|m| m.range()).collect();
159 match found.as_slice() {
160 [one] => Ok(one.clone()),
161 _ => Err(CodeModeError::AnchorCount { name, found: found.len() }),
162 }
163}
164
165fn overwrite_padded(slot: &mut [u8], with: &[u8]) {
167 slot.fill(b' ');
168 for (dst, src) in slot.iter_mut().zip(with) {
169 *dst = *src;
170 }
171}
172
173fn rfind(data: &[u8], needle: &[u8]) -> Option<usize> {
174 data.windows(needle.len()).rposition(|w| w == needle)
175}
176
177fn read_u32(data: &[u8], at: usize) -> Result<usize, CodeModeError> {
178 let bytes = data.get(at..at + 4).and_then(|b| <[u8; 4]>::try_from(b).ok());
179 bytes.map(|b| u32::from_le_bytes(b) as usize).ok_or(CodeModeError::NotBunBinary("truncated"))
180}
181
182fn read_u64(data: &[u8], at: usize) -> Result<u64, CodeModeError> {
183 let bytes = data.get(at..at + 8).and_then(|b| <[u8; 8]>::try_from(b).ok());
184 bytes.map(u64::from_le_bytes).ok_or(CodeModeError::NotBunBinary("truncated"))
185}
186
187static BUILD: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
191
192pub async fn patched_binary(binary: &Path) -> Result<PathBuf, CodeModeError> {
197 if cfg!(windows) {
198 return Err(CodeModeError::UnsupportedPlatform);
199 }
200 let source = tokio::fs::canonicalize(resolve(binary)).await?;
201 let key = source_key(&source).await?;
202 let target = cache_dir().join(format!("{key}-sdk{}", env!("CARGO_PKG_VERSION"))).join("claude");
203
204 let _guard = BUILD.lock().await;
205 if tokio::fs::try_exists(&target).await? {
206 return Ok(target);
207 }
208 let dir = target.parent().ok_or(CodeModeError::NotBunBinary("cache path"))?;
209 tokio::fs::create_dir_all(dir).await?;
210 tokio::fs::write(dir.join(SOURCE_FILE), source.to_string_lossy().as_bytes()).await?;
213
214 let original = tokio::fs::read(&source).await?;
215 let patched = tokio::task::spawn_blocking(move || patch(&original))
216 .await
217 .map_err(|e| CodeModeError::Io(std::io::Error::other(e)))??;
218 let nanos = std::time::SystemTime::now()
221 .duration_since(std::time::UNIX_EPOCH)
222 .map(|d| d.subsec_nanos())
223 .unwrap_or_default();
224 let partial = dir.join(format!("claude.{}.{nanos}.partial", std::process::id()));
225 tokio::fs::write(&partial, patched).await?;
226 #[cfg(unix)]
227 {
228 use std::os::unix::fs::PermissionsExt;
229 tokio::fs::set_permissions(&partial, std::fs::Permissions::from_mode(0o755)).await?;
230 }
231 if let Err(e) = sign(&partial, &source).await {
232 remove_leftover(&partial).await;
233 return Err(e);
234 }
235 tokio::fs::rename(&partial, &target).await?;
236 prune_stale_builds(dir).await;
237 tracing::info!(source = %source.display(), patched = %target.display(), "built Code Mode CLI");
238 Ok(target)
239}
240
241const SOURCE_FILE: &str = "source";
243
244async fn source_key(source: &Path) -> std::io::Result<String> {
246 let meta = tokio::fs::metadata(source).await?;
247 let mtime = meta
248 .modified()?
249 .duration_since(std::time::UNIX_EPOCH)
250 .map(|d| d.as_secs())
251 .unwrap_or_default();
252 let name = source.file_name().map_or_else(|| "claude".into(), |n| n.to_string_lossy().into_owned());
253 Ok(format!("{name}-{}-{mtime}", meta.len()))
254}
255
256async fn prune_stale_builds(current: &Path) {
261 let Some(root) = current.parent() else { return };
262 let Ok(mut entries) = tokio::fs::read_dir(root).await else { return };
263 while let Ok(Some(entry)) = entries.next_entry().await {
264 let path = entry.path();
265 if path != current && is_stale_build(&path).await && tokio::fs::remove_dir_all(&path).await.is_ok() {
266 tracing::debug!(path = %path.display(), "removed stale Code Mode CLI");
267 }
268 }
269}
270
271async fn is_stale_build(dir: &Path) -> bool {
272 match tokio::fs::read(dir.join(SOURCE_FILE)).await {
273 Ok(bytes) => {
274 let source = PathBuf::from(String::from_utf8_lossy(&bytes).into_owned());
275 let name = dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
276 match source_key(&source).await {
277 Ok(key) => !name.starts_with(&format!("{key}-")),
278 Err(_) => true,
279 }
280 }
281 Err(_) => tokio::fs::try_exists(dir.join("claude")).await.unwrap_or(false),
284 }
285}
286
287fn resolve(binary: &Path) -> PathBuf {
289 if binary.components().count() > 1 {
290 return binary.to_path_buf();
291 }
292 std::env::var_os("PATH")
293 .into_iter()
294 .flat_map(|p| std::env::split_paths(&p).collect::<Vec<_>>())
295 .map(|dir| dir.join(binary))
296 .find(|candidate| candidate.is_file())
297 .unwrap_or_else(|| binary.to_path_buf())
298}
299
300async fn remove_leftover(path: &Path) {
302 if let Err(e) = tokio::fs::remove_file(path).await
303 && e.kind() != std::io::ErrorKind::NotFound
304 {
305 tracing::warn!(path = %path.display(), error = %e, "could not remove temporary Code Mode file");
306 }
307}
308
309fn cache_dir() -> PathBuf {
310 let base = std::env::var_os("XDG_CACHE_HOME")
311 .map(PathBuf::from)
312 .or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".cache")))
313 .unwrap_or_else(std::env::temp_dir);
314 base.join("claude-code-agent").join("code-mode")
315}
316
317#[cfg(target_os = "macos")]
320async fn sign(patched: &Path, source: &Path) -> Result<(), CodeModeError> {
321 let ents = codesign(|c| c.args(["-d", "--entitlements", "-", "--xml"]).arg(source)).await?;
322 if !ents.status.success() || !ents.stdout.starts_with(b"<?xml") {
323 return Err(CodeModeError::Sign(format!(
324 "could not read entitlements of {}: {}",
325 source.display(),
326 String::from_utf8_lossy(&ents.stderr).trim()
327 )));
328 }
329 let plist = patched.with_extension("entitlements.plist");
330 tokio::fs::write(&plist, &ents.stdout).await?;
331 let out = codesign(|c| {
332 c.args(["--force", "--sign", "-", "--timestamp=none", "--entitlements"]).arg(&plist).arg(patched)
333 })
334 .await;
335 remove_leftover(&plist).await;
336 let out = out?;
337 if out.status.success() {
338 Ok(())
339 } else {
340 Err(CodeModeError::Sign(String::from_utf8_lossy(&out.stderr).trim().to_string()))
341 }
342}
343
344#[cfg(target_os = "macos")]
347async fn codesign(
348 args: impl FnOnce(&mut tokio::process::Command) -> &mut tokio::process::Command,
349) -> Result<std::process::Output, CodeModeError> {
350 let mut cmd = tokio::process::Command::new("codesign");
351 args(&mut cmd).kill_on_drop(true);
352 tokio::time::timeout(CODESIGN_TIMEOUT, cmd.output()).await.map_err(|_| {
353 std::io::Error::new(std::io::ErrorKind::TimedOut, format!("codesign timed out after {CODESIGN_TIMEOUT:?}"))
354 })?
355 .map_err(CodeModeError::from)
356}
357
358#[cfg(not(target_os = "macos"))]
359async fn sign(_patched: &Path, _source: &Path) -> Result<(), CodeModeError> {
360 Ok(())
361}