@@ -1,7 +1,7 @@
1+use crate::session_manager::{GLOBAL_CACHE_DIR_NAME, INSTANCE_DIR_NAME};
2+use anyhow::{Context, Error, Result, bail};
13use std::{
2− env,
3− ffi::OsString,
4− fs,
4+ env, fs,
55 io::{self, Write},
66 os::{
77 fd::RawFd,
@@ -15,6 +15,7 @@ use std::{
1515 process::{Command, Stdio},
1616 sync::{
1717 Arc, Condvar, Mutex,
18+ atomic::{AtomicBool, Ordering},
1819 mpsc::{self, Receiver, Sender},
1920 },
2021 thread,
@@ -22,8 +23,8 @@ use std::{
2223};
2324
2425use block2::RcBlock;
26+use bytesize::ByteSize;
2527use dispatch2::DispatchQueue;
26−use lexopt::prelude::*;
2728use objc2::{AnyThread, rc::Retained, runtime::ProtocolObject};
2829use objc2_foundation::*;
2930use objc2_virtualization::*;
@@ -32,39 +33,46 @@ const DEBIAN_COMPRESSED_DISK_URL: &str = "https://cloud.debian.org/images/cloud/
3233const DEBIAN_COMPRESSED_SHA: &str = "6ab9be9e6834adc975268367f2f0235251671184345c34ee13031749fdfbf66fe4c3aafd949a2d98550426090e9ac645e79009c51eb0eefc984c15786570bb38";
3334const DEBIAN_COMPRESSED_SIZE_BYTES: u64 = 280901576;
3435const SHARED_DIRECTORIES_TAG: &str = "shared";
36+pub const PROJECT_GUEST_BASE: &str = "/usr/local/vibebox-mounts";
3537
36−const BYTES_PER_MB: u64 = 1024 * 1024;
37−const DEFAULT_CPU_COUNT: usize = 2;
38−const DEFAULT_RAM_MB: u64 = 2048;
39−const DEFAULT_RAM_BYTES: u64 = DEFAULT_RAM_MB * BYTES_PER_MB;
4038const START_TIMEOUT: Duration = Duration::from_secs(60);
41−const DEFAULT_EXPECT_TIMEOUT: Duration = Duration::from_secs(30);
4239const LOGIN_EXPECT_TIMEOUT: Duration = Duration::from_secs(120);
40+const PROVISION_EXPECT_TIMEOUT: Duration = Duration::from_secs(900);
41+
42+const ERROR_REPORT_SCRIPT: &str = include_str!("error_report.sh");
4343const PROVISION_SCRIPT: &str = include_str!("provision.sh");
44+const RESIZE_DISK_SCRIPT: &str = include_str!("resize_disk.sh");
45+const DEFAULT_RAW_NAME: &str = "default.raw";
46+const INSTANCE_RAW_NAME: &str = "instance.raw";
47+const BASE_DISK_RAW_NAME: &str = "disk.raw";
4448
4549#[derive(Clone)]
46−enum LoginAction {
47− Expect { text: String, timeout: Duration },
50+pub enum LoginAction {
51+ Expect {
52+ text: String,
53+ timeout: Duration,
54+ },
55+ ExpectEither {
56+ success: String,
57+ failure: String,
58+ timeout: Duration,
59+ },
4860 Send(String),
49− Script { path: PathBuf, index: usize },
5061}
62+use crate::config::BoxConfig;
5163use LoginAction::*;
5264
5365#[derive(Clone)]
54−struct DirectoryShare {
66+pub struct DirectoryShare {
5567 host: PathBuf,
5668 guest: PathBuf,
5769 read_only: bool,
5870}
5971
6072impl DirectoryShare {
61− fn new(
62− host: PathBuf,
63− mut guest: PathBuf,
64− read_only: bool,
65− ) -> Result<Self, Box<dyn std::error::Error>> {
73+ pub fn new(host: PathBuf, mut guest: PathBuf, read_only: bool) -> Result<Self> {
6674 if !host.exists() {
67− return Err(format!("Host path does not exist: {}", host.display()).into());
75+ bail!(format!("host path does not exist: {}", host.display()));
6876 }
6977 if !guest.is_absolute() {
7078 guest = PathBuf::from("/root").join(guest);
@@ -76,23 +84,22 @@ impl DirectoryShare {
7684 })
7785 }
7886
79− fn from_mount_spec(spec: &str) -> Result<Self, Box<dyn std::error::Error>> {
87+ pub fn from_mount_spec(spec: &str) -> Result<Self> {
8088 let parts: Vec<&str> = spec.split(':').collect();
8189 if parts.len() < 2 || parts.len() > 3 {
82− return Err(format!("Invalid mount spec: {spec}").into());
90+ bail!(format!("invalid mount spec: {spec}"));
8391 }
84− let host = PathBuf::from(parts[0]);
92+ let host = expand_tilde_path(parts[0]);
8593 let guest = PathBuf::from(parts[1]);
8694 let read_only = if parts.len() == 3 {
8795 match parts[2] {
8896 "read-only" => true,
8997 "read-write" => false,
9098 _ => {
91− return Err(format!(
99+ bail!(format!(
92100 "Invalid mount mode '{}'; expected read-only or read-write",
93101 parts[2]
94− )
95− .into());
102+ ));
96103 }
97104 }
98105 } else {
@@ -115,23 +122,49 @@ impl DirectoryShare {
115122 }
116123}
117124
118−pub fn run_cli() -> Result<(), Box<dyn std::error::Error>> {
119− let args = parse_cli()?;
120−
121− if args.version() {
122− print_version();
123− return Ok(());
125+fn expand_tilde_path(value: &str) -> PathBuf {
126+ if let Some(stripped) = value.strip_prefix("~/") {
127+ if let Ok(home) = env::var("HOME") {
128+ return PathBuf::from(home).join(stripped);
129+ }
130+ } else if value == "~"
131+ && let Ok(home) = env::var("HOME")
132+ {
133+ return PathBuf::from(home);
124134 }
135+ PathBuf::from(value)
136+}
125137
126− if args.help() {
127− print_help();
128− return Ok(());
138+pub struct VmArg {
139+ pub cpu_count: usize,
140+ pub ram_bytes: u64,
141+ pub disk_bytes: u64,
142+ pub no_default_mounts: bool,
143+ pub mounts: Vec<String>,
144+}
145+
146+type StatusEmitter<'a> = dyn Fn(&str) + std::marker::Send + Sync + 'a;
147+
148+fn emit_status(status: Option<&StatusEmitter<'_>>, message: &str) {
149+ if let Some(status) = status {
150+ status(message);
129151 }
152+}
130153
131− run_with_args(args, spawn_vm_io)
154+pub fn run_with_args<F>(args: VmArg, io_handler: F) -> Result<()>
155+where
156+ F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
157+{
158+ run_with_args_and_extras(args, io_handler, Vec::new(), Vec::new(), None)
132159}
133160
134−pub fn run_with_args<F>(args: CliArgs, io_handler: F) -> Result<(), Box<dyn std::error::Error>>
161+pub fn run_with_args_and_extras<F>(
162+ args: VmArg,
163+ io_handler: F,
164+ extra_login_actions: Vec<LoginAction>,
165+ extra_directory_shares: Vec<DirectoryShare>,
166+ status: Option<&StatusEmitter<'_>>,
167+) -> Result<()>
135168where
136169 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
137170{
@@ -140,7 +173,7 @@ where
140173 let project_root = env::current_dir()?;
141174 let project_name = project_root
142175 .file_name()
143− .ok_or("Project directory has no name")?
176+ .with_context(|| "Project directory has no name")?
144177 .to_string_lossy()
145178 .into_owned();
146179
@@ -148,10 +181,14 @@ where
148181 let cache_home = env::var("XDG_CACHE_HOME")
149182 .map(PathBuf::from)
150183 .unwrap_or_else(|_| home.join(".cache"));
151− let cache_dir = cache_home.join("vibe");
184+ let cache_dir = cache_home.join(GLOBAL_CACHE_DIR_NAME);
152185 let guest_mise_cache = cache_dir.join(".guest-mise-cache");
153186
154− let instance_dir = project_root.join(".vibe");
187+ let instance_dir = project_root.join(INSTANCE_DIR_NAME);
188+ fs::create_dir_all(&instance_dir)?;
189+ emit_status(status, "preparing VM image...");
190+ tracing::info!("preparing VM image...");
191+ let provision_log = instance_dir.join("provision.log");
155192
156193 let basename_compressed = DEBIAN_COMPRESSED_DISK_URL.rsplit('/').next().unwrap();
157194 let base_compressed = cache_dir.join(basename_compressed);
@@ -160,8 +197,8 @@ where
160197 basename_compressed.trim_end_matches(".tar.xz")
161198 ));
162199
163− let default_raw = cache_dir.join("default.raw");
164− let instance_raw = instance_dir.join("instance.raw");
200+ let default_raw = cache_dir.join(DEFAULT_RAW_NAME);
201+ let instance_raw = instance_dir.join(INSTANCE_RAW_NAME);
165202
166203 // Prepare system-wide directories
167204 fs::create_dir_all(&cache_dir)?;
@@ -170,28 +207,31 @@ where
170207 let mise_directory_share =
171208 DirectoryShare::new(guest_mise_cache, "/root/.local/share/mise".into(), false)?;
172209
173− let disk_path = if let Some(path) = args.disk {
174− if !path.exists() {
175− return Err(format!("Disk image does not exist: {}", path.display()).into());
176− }
177− path
178− } else {
179− ensure_default_image(
180− &base_raw,
181− &base_compressed,
182− &default_raw,
183− std::slice::from_ref(&mise_directory_share),
184− )?;
185− ensure_instance_disk(&instance_raw, &default_raw)?;
186−
187− instance_raw
188− };
210+ ensure_default_image(
211+ &base_raw,
212+ &base_compressed,
213+ &default_raw,
214+ std::slice::from_ref(&mise_directory_share),
215+ Some(&provision_log),
216+ status,
217+ )?;
218+ let _ = ensure_instance_disk(
219+ &instance_raw,
220+ &default_raw,
221+ ByteSize(args.disk_bytes),
222+ status,
223+ )?;
224+ let base_size = fs::metadata(&default_raw)?.len();
225+ let instance_size = fs::metadata(&instance_raw)?.len();
226+ let needs_resize = instance_size > base_size;
227+ let disk_path = instance_raw;
189228
190229 let mut login_actions = Vec::new();
191230 let mut directory_shares = Vec::new();
192231
193232 if !args.no_default_mounts {
194− login_actions.push(Send(format!("cd {project_name}")));
233+ let project_guest_dir = PathBuf::from(PROJECT_GUEST_BASE).join(project_name);
234+ login_actions.push(Send(format!("cd {}", project_guest_dir.display())));
195235
196236 // discourage read/write of .git folder from within the VM. note that this isn't secure, since the VM runs as root and could unmount this.
197237 // I couldn't find an alternative way to do this --- the MacOS sandbox doesn't apply to the Apple Virtualization system
@@ -199,50 +239,25 @@ where
199239 login_actions.push(Send(r"mount -t tmpfs tmpfs .git/".into()));
200240 }
201241
202− directory_shares.push(
203− DirectoryShare::new(
204− project_root,
205− PathBuf::from("/root/").join(project_name),
206− false,
207− )
208− .expect("Project directory must exist"),
209− );
210−
211242 directory_shares.push(mise_directory_share);
212−
213− // Add default shares, if they exist
214− for share in [
215− DirectoryShare::new(home.join(".m2"), "/root/.m2".into(), false),
216− DirectoryShare::new(
217− home.join(".cargo/registry"),
218− "/root/.cargo/registry".into(),
219− false,
220− ),
221− DirectoryShare::new(home.join(".codex"), "/root/.codex".into(), false),
222− DirectoryShare::new(home.join(".claude"), "/root/.claude".into(), false),
223− DirectoryShare::new(
224− "/Users/zhangjie/Documents/Code/CompletePrograms/vibebox/.ssh".into(),
225− "/root/.ssh".into(),
226− true,
227− ),
228− ]
229− .into_iter()
230− .flatten()
231− {
232− directory_shares.push(share)
233− }
234243 }
235244
245+ directory_shares.extend(extra_directory_shares);
246+
236247 for spec in &args.mounts {
237248 directory_shares.push(DirectoryShare::from_mount_spec(spec)?);
238249 }
239250
251+ if needs_resize {
252+ let resize_cmd = script_command_from_content("resize_disk.sh", RESIZE_DISK_SCRIPT)?;
253+ login_actions.push(Send(resize_cmd));
254+ }
255+
240256 if let Some(motd_action) = motd_login_action(&directory_shares) {
241257 login_actions.push(motd_action);
242258 }
243259
244− // Any user-provided login actions must come after our system ones
245− login_actions.extend(args.login_actions);
260+ login_actions.extend(extra_login_actions);
246261
247262 run_vm_with_io(
248263 &disk_path,
@@ -250,184 +265,29 @@ where
250265 &directory_shares[..],
251266 args.cpu_count,
252267 args.ram_bytes,
268+ status,
253269 io_handler,
254270 )
255271}
256272
257−pub fn print_help() {
258− println!(
259− "Vibe is a quick way to spin up a Linux virtual machine on Mac to sandbox LLM agents.
260−
261−vibe [OPTIONS] [disk-image.raw]
262−
263−Options
264−
265− --help Print this help message.
266− --version Print the version (commit SHA).
267− --no-default-mounts Disable all default mounts.
268− --mount host-path:guest-path[:read-only | :read-write] Mount `host-path` inside VM at `guest-path`.
269− Defaults to read-write.
270− Errors if host-path does not exist.
271− --cpus <count> Number of virtual CPUs (default {DEFAULT_CPU_COUNT}).
272− --ram <megabytes> RAM size in megabytes (default {DEFAULT_RAM_MB}).
273− --script <path/to/script.sh> Run script in VM.
274− --send <some-command> Type `some-command` followed by newline into the VM.
275− --expect <string> [timeout-seconds] Wait for `string` to appear in console output before executing next `--script` or `--send`.
276− If `string` does not appear within timeout (default 30 seconds), shutdown VM with error.
277−"
278− );
279−}
280−
281−pub fn print_version() {
282− println!("Vibe");
283− println!("https://github.com/lynaghk/vibe/");
284− println!("Git SHA: {}", env!("GIT_SHA"));
285−}
286−
287−pub struct CliArgs {
288− disk: Option<PathBuf>,
289− version: bool,
290− help: bool,
291− no_default_mounts: bool,
292− mounts: Vec<String>,
293− login_actions: Vec<LoginAction>,
294− cpu_count: usize,
295− ram_bytes: u64,
296−}
297−
298−impl CliArgs {
299− pub fn version(&self) -> bool {
300− self.version
301− }
302−
303− pub fn help(&self) -> bool {
304− self.help
305− }
306−
307− pub fn cpu_count(&self) -> usize {
308− self.cpu_count
309− }
310−
311− pub fn ram_bytes(&self) -> u64 {
312− self.ram_bytes
313− }
314−
315− pub fn ram_mb(&self) -> u64 {
316− self.ram_bytes / BYTES_PER_MB
317− }
318−}
319−
320−pub fn parse_cli() -> Result<CliArgs, Box<dyn std::error::Error>> {
321− parse_cli_from(env::args_os())
322−}
323−
324−pub fn parse_cli_from<I>(args: I) -> Result<CliArgs, Box<dyn std::error::Error>>
325−where
326− I: IntoIterator<Item = OsString>,
327−{
328− fn os_to_string(value: OsString, flag: &str) -> Result<String, Box<dyn std::error::Error>> {
329− value
330− .into_string()
331− .map_err(|_| format!("{flag} expects valid UTF-8").into())
332− }
333−
334− let mut parser = lexopt::Parser::from_iter(args);
335− let mut disk = None;
336− let mut version = false;
337− let mut help = false;
338− let mut no_default_mounts = false;
339− let mut mounts = Vec::new();
340− let mut login_actions = Vec::new();
341− let mut script_index = 0;
342− let mut cpu_count = DEFAULT_CPU_COUNT;
343− let mut ram_bytes = DEFAULT_RAM_BYTES;
344−
345− while let Some(arg) = parser.next()? {
346− match arg {
347− Long("version") => version = true,
348− Long("help") | Short('h') => help = true,
349− Long("no-default-mounts") => no_default_mounts = true,
350− Long("cpus") => {
351− let value = os_to_string(parser.value()?, "--cpus")?.parse()?;
352− if value == 0 {
353− return Err("--cpus must be >= 1".into());
354− }
355− cpu_count = value;
356− }
357− Long("ram") => {
358− let value: u64 = os_to_string(parser.value()?, "--ram")?.parse()?;
359− if value == 0 {
360− return Err("--ram must be >= 1".into());
361− }
362− ram_bytes = value * BYTES_PER_MB;
363− }
364− Long("mount") => {
365− mounts.push(os_to_string(parser.value()?, "--mount")?);
366− }
367− Long("script") => {
368− login_actions.push(Script {
369− path: os_to_string(parser.value()?, "--script")?.into(),
370− index: script_index,
371− });
372− script_index += 1;
373− }
374− Long("send") => {
375− login_actions.push(Send(os_to_string(parser.value()?, "--send")?));
376− }
377− Long("expect") => {
378− let text = os_to_string(parser.value()?, "--expect")?;
379− let timeout = match parser.optional_value() {
380− Some(value) => Duration::from_secs(os_to_string(value, "--expect")?.parse()?),
381− None => DEFAULT_EXPECT_TIMEOUT,
382− };
383− login_actions.push(Expect { text, timeout });
384− }
385− Value(value) => {
386− if disk.is_some() {
387− return Err("Only one disk path may be provided".into());
388− }
389− disk = Some(PathBuf::from(value));
390− }
391− _ => return Err(arg.unexpected().into()),
392− }
393− }
394−
395− Ok(CliArgs {
396− disk,
397− version,
398− help,
399− no_default_mounts,
400− mounts,
401− login_actions,
402− cpu_count,
403− ram_bytes,
404− })
405−}
406−
407−fn script_command_from_path(
408− path: &Path,
409− index: usize,
410−) -> Result<String, Box<dyn std::error::Error>> {
411− let script = fs::read_to_string(path)
412− .map_err(|err| format!("Failed to read script {}: {err}", path.display()))?;
413− let label = format!("{}_{}", index, path.file_name().unwrap().display());
414− script_command_from_content(&label, &script)
415−}
416−
417−fn script_command_from_content(
418− label: &str,
419− script: &str,
420−) -> Result<String, Box<dyn std::error::Error>> {
273+pub fn script_command_from_content(label: &str, script: &str) -> Result<String> {
421274 let marker = "VIBE_SCRIPT_EOF";
422275 let guest_dir = "/tmp/vibe-scripts";
423276 let guest_path = format!("{guest_dir}/{label}.sh");
277+ let script_body = match script.split_once('\n') {
278+ Some((first, rest)) if first.starts_with("#!") => rest,
279+ _ => script,
280+ };
281+ let wrapped_script = ERROR_REPORT_SCRIPT
282+ .replace("__LABEL__", label)
283+ .replace("__SCRIPT_BODY__", script_body);
424284 let command = format!(
425− "mkdir -p {guest_dir}\ncat >{guest_path} <<'{marker}'\n{script}\n{marker}\nchmod +x {guest_path}\n{guest_path}"
285+ "mkdir -p {guest_dir}\ncat >{guest_path} <<'{marker}'\n{wrapped_script}\n{marker}\nchmod +x {guest_path}\n{guest_path}"
426286 );
427287 if script.contains(marker) {
428− return Err(
429− format!("Script '{label}' contains marker '{marker}', cannot safely upload").into(),
430− );
288+ bail!(format!(
289+ "Script '{label}' contains marker '{marker}', cannot safely upload"
290+ ));
431291 }
432292 Ok(command)
433293}
@@ -461,18 +321,6 @@ fn motd_login_action(directory_shares: &[DirectoryShare]) -> Option<LoginAction>
461321 }
462322
463323 let mut output = String::new();
464− output.push_str(
465− "
466−░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░▒▓███████▓▒░░▒▓████████▓▒░
467−░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░
468− ░▒▓█▓▒▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░
469− ░▒▓█▓▒▒▓█▓▒░░▒▓█▓▒░▒▓███████▓▒░░▒▓██████▓▒░
470− ░▒▓█▓▓█▓▒░ ░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░
471− ░▒▓█▓▓█▓▒░ ░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░
472− ░▒▓██▓▒░ ░▒▓█▓▒░▒▓███████▓▒░░▒▓████████▓▒░
473−
474−",
475− );
476324 output.push_str(&format!(
477325 "{host_header:<host_width$} {guest_header:<guest_width$} {mode_header}\n",
478326 host_width = host_width
@@ -503,6 +351,12 @@ enum WaitResult {
503351 Found,
504352}
505353
354+#[derive(PartialEq, Eq)]
355+enum WaitAnyResult {
356+ Timeout,
357+ Found(usize),
358+}
359+
506360pub enum VmInput {
507361 Bytes(Vec<u8>),
508362 Shutdown,
@@ -510,6 +364,7 @@ pub enum VmInput {
510364
511365enum VmOutput {
512366 LoginActionTimeout { action: String, timeout: Duration },
367+ LoginActionFailed { action: String, reason: String },
513368}
514369
515370#[derive(Default)]
@@ -546,20 +401,100 @@ impl OutputMonitor {
546401 WaitResult::Found
547402 }
548403 }
404+
405+ fn wait_for_any(&self, needles: &[&str], timeout: Duration) -> WaitAnyResult {
406+ let mut found: Option<usize> = None;
407+ let (_unused, timeout_result) = self
408+ .condvar
409+ .wait_timeout_while(self.buffer.lock().unwrap(), timeout, |buf| {
410+ if let Some((pos, idx, len)) = find_any(buf, needles) {
411+ *buf = buf[(pos + len)..].to_string();
412+ found = Some(idx);
413+ false
414+ } else {
415+ true
416+ }
417+ })
418+ .unwrap();
419+
420+ if timeout_result.timed_out() {
421+ WaitAnyResult::Timeout
422+ } else {
423+ WaitAnyResult::Found(found.unwrap_or(0))
424+ }
425+ }
426+}
427+
428+fn find_any(buf: &str, needles: &[&str]) -> Option<(usize, usize, usize)> {
429+ let mut best: Option<(usize, usize, usize)> = None; // (pos, idx, len)
430+ for (idx, needle) in needles.iter().enumerate() {
431+ if let Some(pos) = buf.find(needle) {
432+ let candidate = (pos, idx, needle.len());
433+ if best.is_none_or(|b| candidate.0 < b.0) {
434+ best = Some(candidate);
435+ }
436+ }
437+ }
438+ best
439+}
440+
441+#[derive(Debug)]
442+pub struct IoControl {
443+ forward_input: AtomicBool,
444+ forward_output: AtomicBool,
445+ restore_terminal: AtomicBool,
446+}
447+
448+impl IoControl {
449+ pub fn new() -> Arc<Self> {
450+ Arc::new(Self {
451+ forward_input: AtomicBool::new(true),
452+ forward_output: AtomicBool::new(true),
453+ restore_terminal: AtomicBool::new(false),
454+ })
455+ }
456+
457+ pub fn set_forward_input(&self, enabled: bool) {
458+ self.forward_input.store(enabled, Ordering::SeqCst);
459+ }
460+
461+ pub fn set_forward_output(&self, enabled: bool) {
462+ self.forward_output.store(enabled, Ordering::SeqCst);
463+ }
464+
465+ pub fn request_terminal_restore(&self) {
466+ self.restore_terminal.store(true, Ordering::SeqCst);
467+ }
468+
469+ fn forward_input(&self) -> bool {
470+ self.forward_input.load(Ordering::SeqCst)
471+ }
472+
473+ fn forward_output(&self) -> bool {
474+ self.forward_output.load(Ordering::SeqCst)
475+ }
476+
477+ fn take_restore_terminal(&self) -> bool {
478+ self.restore_terminal
479+ .compare_exchange(true, false, Ordering::SeqCst, Ordering::SeqCst)
480+ .is_ok()
481+ }
549482}
550483
551484fn ensure_base_image(
552485 base_raw: &Path,
553486 base_compressed: &Path,
554−) -> Result<(), Box<dyn std::error::Error>> {
487+ status: Option<&StatusEmitter<'_>>,
488+) -> Result<()> {
555489 if base_raw.exists() {
556490 return Ok(());
557491 }
558492
559493 if !base_compressed.exists()
560− || std::fs::metadata(base_compressed).map(|m| m.len())? < DEBIAN_COMPRESSED_SIZE_BYTES
494+ || fs::metadata(base_compressed).map(|m| m.len())? < DEBIAN_COMPRESSED_SIZE_BYTES
561495 {
562− println!("Downloading base image...");
496+ emit_status(status, "downloading base image...");
497+ tracing::info!("downloading base image");
563498 let status = Command::new("curl")
564499 .args([
565500 "--continue-at",
@@ -573,12 +508,14 @@ fn ensure_base_image(
573508 ])
574509 .status()?;
575510 if !status.success() {
576− return Err("Failed to download base image".into());
511+ bail!("failed to download base image");
577512 }
578513 }
579514
580515 // Check SHA
581516 {
517+ emit_status(status, "verifying base image...");
518+ tracing::info!("verifying base image...");
582519 let input = format!("{} {}\n", DEBIAN_COMPRESSED_SHA, base_compressed.display());
583520
584521 let mut child = Command::new("/usr/bin/shasum")
@@ -596,18 +533,25 @@ fn ensure_base_image(
596533
597534 let status = child.wait().expect("failed to wait on child");
598535 if !status.success() {
599− return Err(format!("SHA validation failed for {DEBIAN_COMPRESSED_DISK_URL}").into());
536+ bail!(format!(
537+ "SHA validation failed for {DEBIAN_COMPRESSED_DISK_URL}"
538+ ));
600539 }
601540 }
602541
603− println!("Decompressing base image...");
542+ emit_status(status, "decompressing base image...");
543+ tracing::info!("decompressing base image...");
604544 let status = Command::new("tar")
605− .args(["-xOf", &base_compressed.to_string_lossy(), "disk.raw"])
606− .stdout(std::fs::File::create(base_raw)?)
545+ .args([
546+ "-xOf",
547+ &base_compressed.to_string_lossy(),
548+ BASE_DISK_RAW_NAME,
549+ ])
550+ .stdout(fs::File::create(base_raw)?)
607551 .status()?;
608552
609553 if !status.success() {
610− return Err("Failed to decompress base image".into());
554+ bail!("Failed to decompress base image");
611555 }
612556
613557 Ok(())
@@ -618,24 +562,56 @@ fn ensure_default_image(
618562 base_compressed: &Path,
619563 default_raw: &Path,
620564 directory_shares: &[DirectoryShare],
621−) -> Result<(), Box<dyn std::error::Error>> {
565+ provision_log: Option<&Path>,
566+ status: Option<&StatusEmitter<'_>>,
567+) -> Result<()> {
622568 if default_raw.exists() {
623569 return Ok(());
624570 }
625571
626− ensure_base_image(base_raw, base_compressed)?;
572+ ensure_base_image(base_raw, base_compressed, status)?;
627573
628− println!("Configuring base image...");
574+ emit_status(status, "configuring base image...");
575+ tracing::info!("configuring base image...");
629576 fs::copy(base_raw, default_raw)?;
630577
631578 let provision_command = script_command_from_content("provision.sh", PROVISION_SCRIPT)?;
632− run_vm(
633− default_raw,
634− &[Send(provision_command)],
635− directory_shares,
636− DEFAULT_CPU_COUNT,
637− DEFAULT_RAM_BYTES,
638− )?;
579+ let provision_actions = [
580+ Send(provision_command),
581+ ExpectEither {
582+ success: "VIBEBOX_PROVISION_OK".to_string(),
583+ failure: "VIBEBOX_PROVISION_FAILED".to_string(),
584+ timeout: PROVISION_EXPECT_TIMEOUT,
585+ },
586+ ];
587+ let provision_result = if let Some(log_path) = provision_log {
588+ let log_path = log_path.to_path_buf();
589+ run_vm_with_io(
590+ default_raw,
591+ &provision_actions,
592+ directory_shares,
593+ BoxConfig::default().cpu_count,
594+ BoxConfig::default().ram_size.as_u64(),
595+ status,
596+ move |output_monitor, vm_output_fd, vm_input_fd| {
597+ spawn_vm_io_with_log(output_monitor, vm_output_fd, vm_input_fd, log_path)
598+ },
599+ )
600+ } else {
601+ run_vm(
602+ default_raw,
603+ &provision_actions,
604+ directory_shares,
605+ BoxConfig::default().cpu_count,
606+ BoxConfig::default().ram_size.as_u64(),
607+ status,
608+ )
609+ };
610+
611+ if let Err(err) = provision_result {
612+ let _ = fs::remove_file(default_raw);
613+ return Err(err);
614+ }
639615
640616 Ok(())
641617}
@@ -643,15 +619,47 @@ fn ensure_default_image(
643619fn ensure_instance_disk(
644620 instance_raw: &Path,
645621 template_raw: &Path,
646−) -> Result<(), Box<dyn std::error::Error>> {
622+ target_bytes: ByteSize,
623+ status: Option<&StatusEmitter<'_>>,
624+) -> Result<bool> {
647625 if instance_raw.exists() {
648− return Ok(());
626+ let current_size = ByteSize(fs::metadata(instance_raw)?.len());
627+ if current_size != target_bytes {
628+ let current_gb = current_size;
629+ let target_gb = target_bytes;
630+ tracing::warn!(
631+ "instance disk size does not match config (current {}, config {}); disk_gb applies only on init. Run `vibebox reset` to recreate or set disk_gb to match; using existing disk.",
632+ current_gb,
633+ target_gb
634+ );
635+ }
636+ return Ok(false);
649637 }
650638
651− println!("Creating instance disk from {}...", template_raw.display());
652− std::fs::create_dir_all(instance_raw.parent().unwrap())?;
653− fs::copy(template_raw, instance_raw)?;
654− Ok(())
639+ let template_size = ByteSize(fs::metadata(template_raw)?.len());
640+ if target_bytes < template_size {
641+ bail!(format!(
642+ "Requested disk size {} is smaller than base image size {}",
643+ target_bytes, template_size
644+ ));
645+ }
646+ let target_size = target_bytes;
647+ let needs_resize = target_size > template_size;
648+
649+ emit_status(status, "creating instance disk...");
650+ tracing::info!("creating instance disk...");
651+ tracing::info!(path = %template_raw.display(), "creating instance disk");
652+ fs::create_dir_all(instance_raw.parent().unwrap())?;
653+ if target_size == template_size {
654+ fs::copy(template_raw, instance_raw)?;
655+ return Ok(needs_resize);
656+ }
657+
658+ let mut dst = fs::File::create(instance_raw)?;
659+ dst.set_len(target_size.as_u64())?;
660+ let mut src = fs::File::open(template_raw)?;
661+ std::io::copy(&mut src, &mut dst)?;
662+ Ok(needs_resize)
655663}
656664
657665pub struct IoContext {
@@ -667,15 +675,17 @@ pub fn create_pipe() -> (OwnedFd, OwnedFd) {
667675 (read_stream.into(), write_stream.into())
668676}
669677
670−pub fn spawn_vm_io_with_line_handler<F>(
678+pub fn spawn_vm_io_with_hooks<
679+ F: FnMut(&str) -> bool + std::marker::Send + 'static,
680+ G: FnMut(&[u8]) + std::marker::Send + 'static,
681+>(
671682 output_monitor: Arc<OutputMonitor>,
672683 vm_output_fd: OwnedFd,
673684 vm_input_fd: OwnedFd,
685+ io_control: Arc<IoControl>,
674686 mut on_line: F,
675−) -> IoContext
676−where
677− F: FnMut(&str) -> bool + ::std::marker::Send + 'static,
678−{
687+ mut on_output: G,
688+) -> IoContext {
679689 let (input_tx, input_rx): (Sender<VmInput>, Receiver<VmInput>) = mpsc::channel();
680690
681691 // raw_guard is set when we've put the user's terminal into raw mode because we've attached stdin/stdout to the VM.
@@ -690,7 +700,12 @@ where
690700 Error,
691701 }
692702
693− fn poll_with_wakeup<'a>(main_fd: RawFd, wakeup_fd: RawFd, buf: &'a mut [u8]) -> PollResult<'a> {
703+ fn poll_with_wakeup<'a>(
704+ main_fd: RawFd,
705+ wakeup_fd: RawFd,
706+ buf: &'a mut [u8],
707+ timeout_ms: i32,
708+ ) -> PollResult<'a> {
694709 let mut fds = [
695710 libc::pollfd {
696711 fd: main_fd,
@@ -704,8 +719,12 @@ where
704719 },
705720 ];
706721
707− let ret = unsafe { libc::poll(fds.as_mut_ptr(), 2, -1) };
708− if ret <= 0 || fds[1].revents & libc::POLLIN != 0 {
722+ let ret = unsafe { libc::poll(fds.as_mut_ptr(), 2, timeout_ms) };
723+ if ret == 0 {
724+ PollResult::Spurious
725+ } else if ret < 0 {
726+ PollResult::Error
727+ } else if fds[1].revents & libc::POLLIN != 0 {
709728 PollResult::Shutdown
710729 } else if fds[0].revents & libc::POLLIN != 0 {
711730 let n = unsafe { libc::read(main_fd, buf.as_mut_ptr() as *mut _, buf.len()) };
@@ -721,18 +740,37 @@ where
721740 }
722741 }
723742
743+ fn poll_wakeup_only(wakeup_fd: RawFd, timeout_ms: i32) -> bool {
744+ let mut fds = [libc::pollfd {
745+ fd: wakeup_fd,
746+ events: libc::POLLIN,
747+ revents: 0,
748+ }];
749+
750+ let ret = unsafe { libc::poll(fds.as_mut_ptr(), 1, timeout_ms) };
751+ ret > 0 && fds[0].revents & libc::POLLIN != 0
752+ }
753+
724754 // Copies from stdin to the VM; also polls wakeup_read to exit the thread when it's time to shutdown.
725755 let stdin_thread = thread::spawn({
726756 let input_tx = input_tx.clone();
727757 let raw_guard = raw_guard.clone();
728758 let wakeup_read = wakeup_read.try_clone().unwrap();
759+ let io_control = io_control.clone();
729760
730761 move || {
731762 let mut buf = [0u8; 1024];
732763 let mut pending_command: Vec<u8> = Vec::new();
733764 let mut command_mode = false;
734765 loop {
735− match poll_with_wakeup(libc::STDIN_FILENO, wakeup_read.as_raw_fd(), &mut buf) {
766+ if !io_control.forward_input() {
767+ if poll_wakeup_only(wakeup_read.as_raw_fd(), 100) {
768+ break;
769+ }
770+ continue;
771+ }
772+
773+ match poll_with_wakeup(libc::STDIN_FILENO, wakeup_read.as_raw_fd(), &mut buf, -1) {
736774 PollResult::Shutdown | PollResult::Error => break,
737775 PollResult::Spurious => continue,
738776 PollResult::Ready(bytes) => {
@@ -776,28 +814,40 @@ where
776814 let stdout_thread = thread::spawn({
777815 let raw_guard = raw_guard.clone();
778816 let wakeup_read = wakeup_read.try_clone().unwrap();
817+ let io_control = io_control.clone();
779818
780819 move || {
781− let mut stdout = std::io::stdout().lock();
782820 let mut buf = [0u8; 1024];
783821 loop {
784− match poll_with_wakeup(vm_output_fd.as_raw_fd(), wakeup_read.as_raw_fd(), &mut buf)
785− {
822+ if io_control.take_restore_terminal() {
823+ let mut guard = raw_guard.lock().unwrap();
824+ *guard = None;
825+ }
826+ match poll_with_wakeup(
827+ vm_output_fd.as_raw_fd(),
828+ wakeup_read.as_raw_fd(),
829+ &mut buf,
830+ 100,
831+ ) {
786832 PollResult::Shutdown | PollResult::Error => break,
787833 PollResult::Spurious => continue,
788834 PollResult::Ready(bytes) => {
789− // enable raw mode, if we haven't already
790− if raw_guard.lock().unwrap().is_none()
791− && let Ok(guard) = enable_raw_mode(libc::STDIN_FILENO)
792− {
793− *raw_guard.lock().unwrap() = Some(guard);
794− }
835+ if io_control.forward_output() {
836+ // enable raw mode if we haven't already
837+ if raw_guard.lock().unwrap().is_none()
838+ && let Ok(guard) = enable_raw_mode(libc::STDIN_FILENO)
839+ {
840+ *raw_guard.lock().unwrap() = Some(guard);
841+ }
795842
796− if stdout.write_all(bytes).is_err() {
797− break;
843+ let mut stdout = io::stdout().lock();
844+ if stdout.write_all(bytes).is_err() {
845+ break;
846+ }
847+ let _ = stdout.flush();
798848 }
799− let _ = stdout.flush();
800849 output_monitor.push(bytes);
850+ on_output(bytes);
801851 }
802852 }
803853 }
@@ -806,7 +856,7 @@ where
806856
807857 // Copies data from mpsc channel into VM, so vibe can "type" stuff and run scripts.
808858 let mux_thread = thread::spawn(move || {
809− let mut vm_writer = std::fs::File::from(vm_input_fd);
859+ let mut vm_writer = fs::File::from(vm_input_fd);
810860 loop {
811861 match input_rx.recv() {
812862 Ok(VmInput::Bytes(data)) => {
@@ -829,6 +879,25 @@ where
829879 }
830880}
831881
882+pub fn spawn_vm_io_with_line_handler<F>(
883+ output_monitor: Arc<OutputMonitor>,
884+ vm_output_fd: OwnedFd,
885+ vm_input_fd: OwnedFd,
886+ on_line: F,
887+) -> IoContext
888+where
889+ F: FnMut(&str) -> bool + std::marker::Send + 'static,
890+{
891+ spawn_vm_io_with_hooks(
892+ output_monitor,
893+ vm_output_fd,
894+ vm_input_fd,
895+ IoControl::new(),
896+ on_line,
897+ |_| {},
898+ )
899+}
900+
832901pub fn spawn_vm_io(
833902 output_monitor: Arc<OutputMonitor>,
834903 vm_output_fd: OwnedFd,
@@ -837,6 +906,36 @@ pub fn spawn_vm_io(
837906 spawn_vm_io_with_line_handler(output_monitor, vm_output_fd, vm_input_fd, |_| false)
838907}
839908
909+fn spawn_vm_io_with_log(
910+ output_monitor: Arc<OutputMonitor>,
911+ vm_output_fd: OwnedFd,
912+ vm_input_fd: OwnedFd,
913+ log_path: PathBuf,
914+) -> IoContext {
915+ let log_file = fs::OpenOptions::new()
916+ .create(true)
917+ .write(true)
918+ .truncate(true)
919+ .open(&log_path)
920+ .ok()
921+ .map(|file| Arc::new(Mutex::new(file)));
922+
923+ spawn_vm_io_with_hooks(
924+ output_monitor,
925+ vm_output_fd,
926+ vm_input_fd,
927+ IoControl::new(),
928+ |_| false,
929+ move |bytes| {
930+ if let Some(log) = &log_file
931+ && let Ok(mut file) = log.lock()
932+ {
933+ let _ = file.write_all(bytes);
934+ }
935+ },
936+ )
937+}
938+
840939impl IoContext {
841940 pub fn shutdown(self) {
842941 let _ = self.input_tx.send(VmInput::Shutdown);
@@ -854,7 +953,7 @@ fn create_vm_configuration(
854953 vm_writes_to_fd: OwnedFd,
855954 cpu_count: usize,
856955 ram_bytes: u64,
857−) -> Result<Retained<VZVirtualMachineConfiguration>, Box<dyn std::error::Error>> {
956+) -> Result<Retained<VZVirtualMachineConfiguration>> {
858957 unsafe {
859958 let platform =
860959 VZGenericPlatformConfiguration::init(VZGenericPlatformConfiguration::alloc());
@@ -888,7 +987,7 @@ fn create_vm_configuration(
888987 false,
889988 VZDiskImageCachingMode::Automatic,
890989 VZDiskImageSynchronizationMode::Full,
891− ).unwrap();
990+ )?;
892991
893992 let disk_device = VZVirtioBlockDeviceConfiguration::initWithAttachment(
894993 VZVirtioBlockDeviceConfiguration::alloc(),
@@ -975,7 +1074,7 @@ fn create_vm_configuration(
9751074 // Validate
9761075 config.validateWithError().map_err(|e| {
9771076 io::Error::other(format!(
978− "Invalid VM configuration: {:?}",
1077+ "invalid VM configuration: {:?}",
9791078 e.localizedDescription()
9801079 ))
9811080 })?;
@@ -984,9 +1083,9 @@ fn create_vm_configuration(
9841083 }
9851084}
9861085
987−fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>, Box<dyn std::error::Error>> {
1086+fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>> {
9881087 unsafe {
989− let temp_dir = std::env::temp_dir();
1088+ let temp_dir = env::temp_dir();
9901089 let temp_path = temp_dir.join(format!("efi_variable_store_{}.efivars", std::process::id()));
9911090 let url = nsurl_from_path(&temp_path)?;
9921091 let options = VZEFIVariableStoreInitializationOptions::AllowOverwrite;
@@ -1002,8 +1101,8 @@ fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>, Box<dyn std
10021101fn spawn_login_actions_thread(
10031102 login_actions: Vec<LoginAction>,
10041103 output_monitor: Arc<OutputMonitor>,
1005− input_tx: mpsc::Sender<VmInput>,
1006− vm_output_tx: mpsc::Sender<VmOutput>,
1104+ input_tx: Sender<VmInput>,
1105+ vm_output_tx: Sender<VmOutput>,
10071106) -> thread::JoinHandle<()> {
10081107 thread::spawn(move || {
10091108 for a in login_actions {
@@ -1017,22 +1116,31 @@ fn spawn_login_actions_thread(
10171116 return;
10181117 }
10191118 }
1119+ ExpectEither {
1120+ success,
1121+ failure,
1122+ timeout,
1123+ } => match output_monitor.wait_for_any(&[&success, &failure], timeout) {
1124+ WaitAnyResult::Found(0) => {}
1125+ WaitAnyResult::Found(_) => {
1126+ let _ = vm_output_tx.send(VmOutput::LoginActionFailed {
1127+ action: format!("expect '{}'", success),
1128+ reason: format!("saw failure marker '{}'", failure),
1129+ });
1130+ return;
1131+ }
1132+ WaitAnyResult::Timeout => {
1133+ let _ = vm_output_tx.send(VmOutput::LoginActionTimeout {
1134+ action: format!("expect '{}'", success),
1135+ timeout,
1136+ });
1137+ return;
1138+ }
1139+ },
10201140 Send(mut text) => {
10211141 text.push('\n'); // Type the newline so the command is actually submitted.
10221142 input_tx.send(VmInput::Bytes(text.into_bytes())).unwrap();
10231143 }
1024− Script { path, index } => {
1025− let command = match script_command_from_path(&path, index) {
1026− Ok(command) => command,
1027− Err(err) => {
1028− eprintln!("{err}");
1029− return;
1030− }
1031− };
1032− let mut text = command;
1033− text.push('\n');
1034− input_tx.send(VmInput::Bytes(text.into_bytes())).unwrap();
1035− }
10361144 }
10371145 }
10381146 })
@@ -1044,8 +1152,9 @@ fn run_vm_with_io<F>(
10441152 directory_shares: &[DirectoryShare],
10451153 cpu_count: usize,
10461154 ram_bytes: u64,
1155+ status: Option<&StatusEmitter<'_>>,
10471156 io_handler: F,
1048−) -> Result<(), Box<dyn std::error::Error>>
1157+) -> Result<()>
10491158where
10501159 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
10511160{
@@ -1092,21 +1201,23 @@ where
10921201
10931202 match rx.try_recv() {
10941203 Ok(result) => {
1095− result.map_err(|e| format!("Failed to start VM: {}", e))?;
1204+ result.map_err(|e| Error::msg(format!("Failed to start VM: {}", e)))?;
10961205 break;
10971206 }
10981207 Err(mpsc::TryRecvError::Empty) => continue,
10991208 Err(mpsc::TryRecvError::Disconnected) => {
1100− return Err("VM start channel disconnected".into());
1209+ bail!("VM start channel disconnected");
11011210 }
11021211 }
11031212 }
11041213
11051214 if Instant::now() >= start_deadline {
1106− return Err("Timed out waiting for VM to start".into());
1215+ bail!("Timed out waiting for VM to start");
11071216 }
11081217
1109− println!("VM booting...");
1218+ emit_status(status, "vm booting... go vibecoder!");
1219+ tracing::info!("vm booting... go vibecoder!");
1220+ tracing::info!("vm booting");
11101221
11111222 let output_monitor = Arc::new(OutputMonitor::default());
11121223 let io_ctx = io_handler(output_monitor.clone(), we_read_from, we_write_to);
@@ -1151,7 +1262,7 @@ where
11511262 );
11521263
11531264 let mut last_state = None;
1154− let mut exit_result = Ok(());
1265+ let mut exit_result: Result<(), String> = Ok(());
11551266 loop {
11561267 unsafe {
11571268 NSRunLoop::mainRunLoop().runMode_beforeDate(
@@ -1170,12 +1281,28 @@ where
11701281 exit_result = Err(format!(
11711282 "Login action ({}) timed out after {:?}; shutting down.",
11721283 action, timeout
1173− )
1174− .into());
1284+ ));
1285+ unsafe {
1286+ if vm.canRequestStop() {
1287+ if let Err(err) = vm.requestStopWithError() {
1288+ tracing::error!(error = ?err, "failed to request VM stop");
1289+ }
1290+ } else if vm.canStop() {
1291+ let handler = RcBlock::new(|_error: *mut NSError| {});
1292+ vm.stopWithCompletionHandler(&handler);
1293+ }
1294+ }
1295+ break;
1296+ }
1297+ Ok(VmOutput::LoginActionFailed { action, reason }) => {
1298+ exit_result = Err(format!(
1299+ "Login action ({}) failed: {}; shutting down.",
1300+ action, reason
1301+ ));
11751302 unsafe {
11761303 if vm.canRequestStop() {
11771304 if let Err(err) = vm.requestStopWithError() {
1178− eprintln!("Failed to request VM stop: {:?}", err);
1305+ tracing::error!(error = ?err, "failed to request VM stop");
11791306 }
11801307 } else if vm.canStop() {
11811308 let handler = RcBlock::new(|_error: *mut NSError| {});
@@ -1187,7 +1314,7 @@ where
11871314 Err(mpsc::TryRecvError::Empty) => {}
11881315 Err(mpsc::TryRecvError::Disconnected) => {}
11891316 }
1190− if state != objc2_virtualization::VZVirtualMachineState::Running {
1317+ if state != VZVirtualMachineState::Running {
11911318 //eprintln!("VM stopped with state: {:?}", state);
11921319 break;
11931320 }
@@ -1197,7 +1324,7 @@ where
11971324
11981325 io_ctx.shutdown();
11991326
1200− exit_result
1327+ exit_result.map_err(Error::msg)
12011328}
12021329
12031330fn run_vm(
@@ -1206,18 +1333,20 @@ fn run_vm(
12061333 directory_shares: &[DirectoryShare],
12071334 cpu_count: usize,
12081335 ram_bytes: u64,
1209−) -> Result<(), Box<dyn std::error::Error>> {
1336+ status: Option<&StatusEmitter<'_>>,
1337+) -> Result<()> {
12101338 run_vm_with_io(
12111339 disk_path,
12121340 login_actions,
12131341 directory_shares,
12141342 cpu_count,
12151343 ram_bytes,
1344+ status,
12161345 spawn_vm_io,
12171346 )
12181347}
12191348
1220−fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>, Box<dyn std::error::Error>> {
1349+fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>> {
12211350 let abs_path = if path.is_absolute() {
12221351 path.to_path_buf()
12231352 } else {
@@ -1226,7 +1355,7 @@ fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>, Box<dyn std::error::E
12261355 let ns_path = NSString::from_str(
12271356 abs_path
12281357 .to_str()
1229− .ok_or("Non-UTF8 path encountered while building NSURL")?,
1358+ .with_context(|| "non-UTF8 path encountered while building NSURL")?,
12301359 );
12311360 Ok(NSURL::fileURLWithPath(&ns_path))
12321361}
@@ -1241,7 +1370,7 @@ fn enable_raw_mode(fd: i32) -> io::Result<RawModeGuard> {
12411370 let original = attributes;
12421371
12431372 // Disable translation of carriage return to newline on input
1244− attributes.c_iflag &= !(libc::ICRNL);
1373+ attributes.c_iflag &= !libc::ICRNL;
12451374 // Disable canonical mode (line buffering), echo, and signal generation
12461375 attributes.c_lflag &= !(libc::ICANON | libc::ECHO | libc::ISIG);
12471376 attributes.c_cc[libc::VMIN] = 0;
@@ -1269,7 +1398,10 @@ impl Drop for RawModeGuard {
12691398
12701399// Ensure the running binary has com.apple.security.virtualization entitlements by checking and, if not, signing and relaunching.
12711400pub fn ensure_signed() {
1272− let exe = std::env::current_exe().expect("failed to get current exe path");
1401+ if env::var("VIBEBOX_SKIP_CODESIGN").as_deref() == Ok("1") {
1402+ return;
1403+ }
1404+ let exe = env::current_exe().expect("failed to get current exe path");
12731405 let exe_str = exe.to_str().expect("exe path not valid utf-8");
12741406
12751407 let has_required_entitlements = {
@@ -1291,10 +1423,10 @@ pub fn ensure_signed() {
12911423 }
12921424
12931425 const ENTITLEMENTS: &str = include_str!("entitlements.plist");
1294− let entitlements_path = std::env::temp_dir().join("entitlements.plist");
1295− std::fs::write(&entitlements_path, ENTITLEMENTS).expect("failed to write entitlements");
1426+ let entitlements_path = env::temp_dir().join("entitlements.plist");
1427+ fs::write(&entitlements_path, ENTITLEMENTS).expect("failed to write entitlements");
12961428
1297− let status = Command::new("codesign")
1429+ let output = Command::new("codesign")
12981430 .args([
12991431 "--sign",
13001432 "-",
@@ -1303,22 +1435,27 @@ pub fn ensure_signed() {
13031435 entitlements_path.to_str().unwrap(),
13041436 exe_str,
13051437 ])
1306− .status();
1438+ .output();
13071439
1308− let _ = std::fs::remove_file(&entitlements_path);
1440+ let _ = fs::remove_file(&entitlements_path);
13091441
1310− match status {
1311− Ok(s) if s.success() => {
1312− let err = Command::new(&exe).args(std::env::args_os().skip(1)).exec();
1313− eprintln!("failed to re-exec after signing: {err}");
1442+ match output {
1443+ Ok(o) if o.status.success() => {
1444+ let stderr = String::from_utf8_lossy(&o.stderr);
1445+ if !stderr.trim().is_empty() {
1446+ tracing::debug!(codesign_stderr = %stderr.trim(), "codesign output");
1447+ }
1448+ let err = Command::new(&exe).args(env::args_os().skip(1)).exec();
1449+ tracing::error!(error = %err, "failed to re-exec after signing");
13141450 std::process::exit(1);
13151451 }
1316− Ok(s) => {
1317− eprintln!("codesign failed with status: {s}");
1452+ Ok(o) => {
1453+ let stderr = String::from_utf8_lossy(&o.stderr);
1454+ tracing::error!(status = %o.status, codesign_stderr = %stderr.trim(), "codesign failed");
13181455 std::process::exit(1);
13191456 }
13201457 Err(e) => {
1321− eprintln!("failed to run codesign: {e}");
1458+ tracing::error!(error = %e, "failed to run codesign");
13221459 std::process::exit(1);
13231460 }
13241461 }