@@ -1,5 +1,5 @@
1+use crate::instance::STATUS_FILE_NAME;
1use crate::session_manager::{GLOBAL_CACHE_DIR_NAME, INSTANCE_DIR_NAME};
2use crate::session_manager::{GLOBAL_CACHE_DIR_NAME, INSTANCE_DIR_NAME};
2−use anyhow::{Context, Error, Result, bail};
5 io::{self, Write},
5 io::{self, Write},
@@ -23,7 +23,6 @@ use std::{
25use block2::RcBlock;
25use block2::RcBlock;
26−use bytesize::ByteSize;
27use dispatch2::DispatchQueue;
26use dispatch2::DispatchQueue;
28use objc2::{AnyThread, rc::Retained, runtime::ProtocolObject};
27use objc2::{AnyThread, rc::Retained, runtime::ProtocolObject};
29use objc2_foundation::*;
28use objc2_foundation::*;
@@ -33,46 +32,74 @@ const DEBIAN_COMPRESSED_DISK_URL: &str = "https://cloud.debian.org/images/cloud/
33const DEBIAN_COMPRESSED_SHA: &str = "6ab9be9e6834adc975268367f2f0235251671184345c34ee13031749fdfbf66fe4c3aafd949a2d98550426090e9ac645e79009c51eb0eefc984c15786570bb38";
32const DEBIAN_COMPRESSED_SHA: &str = "6ab9be9e6834adc975268367f2f0235251671184345c34ee13031749fdfbf66fe4c3aafd949a2d98550426090e9ac645e79009c51eb0eefc984c15786570bb38";
34const DEBIAN_COMPRESSED_SIZE_BYTES: u64 = 280901576;
33const DEBIAN_COMPRESSED_SIZE_BYTES: u64 = 280901576;
35const SHARED_DIRECTORIES_TAG: &str = "shared";
34const SHARED_DIRECTORIES_TAG: &str = "shared";
36−pub const PROJECT_GUEST_BASE: &str = "/usr/local/vibebox-mounts";
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;
38const START_TIMEOUT: Duration = Duration::from_secs(60);
40const START_TIMEOUT: Duration = Duration::from_secs(60);
39const LOGIN_EXPECT_TIMEOUT: Duration = Duration::from_secs(120);
41const LOGIN_EXPECT_TIMEOUT: Duration = Duration::from_secs(120);
40−const PROVISION_EXPECT_TIMEOUT: Duration = Duration::from_secs(900);
42−const ERROR_REPORT_SCRIPT: &str = include_str!("error_report.sh");
43+struct StatusFile {
49+ fn new(path: PathBuf) -> Self {
52+ cleared: AtomicBool::new(false),
56+ fn update(&self, message: &str) {
57+ let _ = fs::write(&self.path, message);
61+ if !self.cleared.swap(true, Ordering::SeqCst) {
62+ let _ = fs::remove_file(&self.path);
67+impl Drop for StatusFile {
69+ if !self.cleared.load(Ordering::SeqCst) {
70+ let _ = fs::remove_file(&self.path);
71+ self.cleared.store(true, Ordering::SeqCst);
43const PROVISION_SCRIPT: &str = include_str!("provision.sh");
75const PROVISION_SCRIPT: &str = include_str!("provision.sh");
44−const RESIZE_DISK_SCRIPT: &str = include_str!("resize_disk.sh");
76+const PROVISION_SCRIPT_NAME: &str = "provision.sh";
45const DEFAULT_RAW_NAME: &str = "default.raw";
77const DEFAULT_RAW_NAME: &str = "default.raw";
46const INSTANCE_RAW_NAME: &str = "instance.raw";
78const INSTANCE_RAW_NAME: &str = "instance.raw";
47const BASE_DISK_RAW_NAME: &str = "disk.raw";
79const BASE_DISK_RAW_NAME: &str = "disk.raw";
49#[derive(Clone)]
81#[derive(Clone)]
50−pub enum LoginAction {
82+pub(crate) enum LoginAction {
58− timeout: Duration,
83+ Expect { text: String, timeout: Duration },
60 Send(String),
84 Send(String),
62−use crate::config::BoxConfig;
63use LoginAction::*;
86use LoginAction::*;
65#[derive(Clone)]
88#[derive(Clone)]
66−pub struct DirectoryShare {
89+pub(crate) struct DirectoryShare {
67 host: PathBuf,
90 host: PathBuf,
68 guest: PathBuf,
91 guest: PathBuf,
69 read_only: bool,
92 read_only: bool,
72impl DirectoryShare {
95impl DirectoryShare {
73− pub fn new(host: PathBuf, mut guest: PathBuf, read_only: bool) -> Result<Self> {
98+ mut guest: PathBuf,
100+ ) -> Result<Self, Box<dyn std::error::Error>> {
74 if !host.exists() {
101 if !host.exists() {
75− bail!(format!("host path does not exist: {}", host.display()));
102+ return Err(format!("Host path does not exist: {}", host.display()).into());
77 if !guest.is_absolute() {
104 if !guest.is_absolute() {
78 guest = PathBuf::from("/root").join(guest);
105 guest = PathBuf::from("/root").join(guest);
@@ -84,10 +111,10 @@ impl DirectoryShare {
87− pub fn from_mount_spec(spec: &str) -> Result<Self> {
114+ pub(crate) fn from_mount_spec(spec: &str) -> Result<Self, Box<dyn std::error::Error>> {
88 let parts: Vec<&str> = spec.split(':').collect();
115 let parts: Vec<&str> = spec.split(':').collect();
89 if parts.len() < 2 || parts.len() > 3 {
116 if parts.len() < 2 || parts.len() > 3 {
90− bail!(format!("invalid mount spec: {spec}"));
117+ return Err(format!("Invalid mount spec: {spec}").into());
92 let host = expand_tilde_path(parts[0]);
119 let host = expand_tilde_path(parts[0]);
93 let guest = PathBuf::from(parts[1]);
120 let guest = PathBuf::from(parts[1]);
@@ -96,10 +123,11 @@ impl DirectoryShare {
96 "read-only" => true,
123 "read-only" => true,
97 "read-write" => false,
124 "read-write" => false,
99− bail!(format!(
126+ return Err(format!(
100 "Invalid mount mode '{}'; expected read-only or read-write",
127 "Invalid mount mode '{}'; expected read-only or read-write",
@@ -127,10 +155,10 @@ fn expand_tilde_path(value: &str) -> PathBuf {
127 if let Ok(home) = env::var("HOME") {
155 if let Ok(home) = env::var("HOME") {
128 return PathBuf::from(home).join(stripped);
156 return PathBuf::from(home).join(stripped);
130− } else if value == "~"
158+ } else if value == "~" {
131− && let Ok(home) = env::var("HOME")
159+ if let Ok(home) = env::var("HOME") {
133− return PathBuf::from(home);
160+ return PathBuf::from(home);
135 PathBuf::from(value)
163 PathBuf::from(value)
@@ -138,33 +166,23 @@ fn expand_tilde_path(value: &str) -> PathBuf {
138pub struct VmArg {
166pub struct VmArg {
139 pub cpu_count: usize,
167 pub cpu_count: usize,
140 pub ram_bytes: u64,
168 pub ram_bytes: u64,
141− pub disk_bytes: u64,
142 pub no_default_mounts: bool,
169 pub no_default_mounts: bool,
143 pub mounts: Vec<String>,
170 pub mounts: Vec<String>,
146−type StatusEmitter<'a> = dyn Fn(&str) + std::marker::Send + Sync + 'a;
148−fn emit_status(status: Option<&StatusEmitter<'_>>, message: &str) {
149− if let Some(status) = status {
154−pub fn run_with_args<F>(args: VmArg, io_handler: F) -> Result<()>
173+pub fn run_with_args<F>(args: VmArg, io_handler: F) -> Result<(), Box<dyn std::error::Error>>
156 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
175 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
158− run_with_args_and_extras(args, io_handler, Vec::new(), Vec::new(), None)
177+ run_with_args_and_extras(args, io_handler, Vec::new(), Vec::new())
161−pub fn run_with_args_and_extras<F>(
180+pub(crate) fn run_with_args_and_extras<F>(
162 args: VmArg,
181 args: VmArg,
163 io_handler: F,
182 io_handler: F,
164 extra_login_actions: Vec<LoginAction>,
183 extra_login_actions: Vec<LoginAction>,
165 extra_directory_shares: Vec<DirectoryShare>,
184 extra_directory_shares: Vec<DirectoryShare>,
166− status: Option<&StatusEmitter<'_>>,
185+) -> Result<(), Box<dyn std::error::Error>>
169 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
187 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
@@ -173,7 +191,7 @@ where
173 let project_root = env::current_dir()?;
191 let project_root = env::current_dir()?;
174 let project_name = project_root
192 let project_name = project_root
175 .file_name()
193 .file_name()
176− .with_context(|| "Project directory has no name")?
194+ .ok_or("Project directory has no name")?
177 .to_string_lossy()
195 .to_string_lossy()
178 .into_owned();
196 .into_owned();
@@ -185,10 +203,8 @@ where
185 let guest_mise_cache = cache_dir.join(".guest-mise-cache");
203 let guest_mise_cache = cache_dir.join(".guest-mise-cache");
187 let instance_dir = project_root.join(INSTANCE_DIR_NAME);
205 let instance_dir = project_root.join(INSTANCE_DIR_NAME);
188− fs::create_dir_all(&instance_dir)?;
206+ let status_file = StatusFile::new(instance_dir.join(STATUS_FILE_NAME));
189− emit_status(status, "preparing VM image...");
207+ status_file.update("preparing VM image...");
190− tracing::info!("preparing VM image...");
191− let provision_log = instance_dir.join("provision.log");
193 let basename_compressed = DEBIAN_COMPRESSED_DISK_URL.rsplit('/').next().unwrap();
209 let basename_compressed = DEBIAN_COMPRESSED_DISK_URL.rsplit('/').next().unwrap();
194 let base_compressed = cache_dir.join(basename_compressed);
210 let base_compressed = cache_dir.join(basename_compressed);
@@ -212,26 +228,16 @@ where
212 &base_compressed,
228 &base_compressed,
213 &default_raw,
229 &default_raw,
214 std::slice::from_ref(&mise_directory_share),
230 std::slice::from_ref(&mise_directory_share),
215− Some(&provision_log),
231+ Some(&status_file),
218− let _ = ensure_instance_disk(
221− ByteSize(args.disk_bytes),
224− let base_size = fs::metadata(&default_raw)?.len();
233+ ensure_instance_disk(&instance_raw, &default_raw, Some(&status_file))?;
225− let instance_size = fs::metadata(&instance_raw)?.len();
226− let needs_resize = instance_size > base_size;
227 let disk_path = instance_raw;
234 let disk_path = instance_raw;
229 let mut login_actions = Vec::new();
236 let mut login_actions = Vec::new();
230 let mut directory_shares = Vec::new();
237 let mut directory_shares = Vec::new();
232 if !args.no_default_mounts {
239 if !args.no_default_mounts {
233− let project_guest_dir = PathBuf::from(PROJECT_GUEST_BASE).join(project_name);
234− login_actions.push(Send(format!("cd {}", project_guest_dir.display())));
240+ login_actions.push(Send(format!("cd {project_name}")));
236 // 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.
242 // 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.
237 // I couldn't find an alternative way to do this --- the MacOS sandbox doesn't apply to the Apple Virtualization system
243 // I couldn't find an alternative way to do this --- the MacOS sandbox doesn't apply to the Apple Virtualization system
@@ -239,6 +245,15 @@ where
239 login_actions.push(Send(r"mount -t tmpfs tmpfs .git/".into()));
245 login_actions.push(Send(r"mount -t tmpfs tmpfs .git/".into()));
248+ directory_shares.push(
249+ DirectoryShare::new(
251+ PathBuf::from("/root/").join(project_name),
254+ .expect("Project directory must exist"),
242 directory_shares.push(mise_directory_share);
257 directory_shares.push(mise_directory_share);
@@ -248,11 +263,6 @@ where
248 directory_shares.push(DirectoryShare::from_mount_spec(spec)?);
263 directory_shares.push(DirectoryShare::from_mount_spec(spec)?);
252− let resize_cmd = script_command_from_content("resize_disk.sh", RESIZE_DISK_SCRIPT)?;
253− login_actions.push(Send(resize_cmd));
256 if let Some(motd_action) = motd_login_action(&directory_shares) {
266 if let Some(motd_action) = motd_login_action(&directory_shares) {
257 login_actions.push(motd_action);
267 login_actions.push(motd_action);
@@ -265,29 +275,25 @@ where
265 &directory_shares[..],
275 &directory_shares[..],
266 args.cpu_count,
276 args.cpu_count,
267 args.ram_bytes,
277 args.ram_bytes,
268− status,
278+ Some(&status_file),
269 io_handler,
279 io_handler,
273−pub fn script_command_from_content(label: &str, script: &str) -> Result<String> {
283+pub(crate) fn script_command_from_content(
286+) -> Result<String, Box<dyn std::error::Error>> {
274 let marker = "VIBE_SCRIPT_EOF";
287 let marker = "VIBE_SCRIPT_EOF";
275 let guest_dir = "/tmp/vibe-scripts";
288 let guest_dir = "/tmp/vibe-scripts";
276 let guest_path = format!("{guest_dir}/{label}.sh");
289 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,
281− let wrapped_script = ERROR_REPORT_SCRIPT
282− .replace("__LABEL__", label)
283− .replace("__SCRIPT_BODY__", script_body);
284 let command = format!(
290 let command = format!(
285− "mkdir -p {guest_dir}\ncat >{guest_path} <<'{marker}'\n{wrapped_script}\n{marker}\nchmod +x {guest_path}\n{guest_path}"
291+ "mkdir -p {guest_dir}\ncat >{guest_path} <<'{marker}'\n{script}\n{marker}\nchmod +x {guest_path}\n{guest_path}"
287 if script.contains(marker) {
293 if script.contains(marker) {
288− bail!(format!(
294+ return Err(
289− "Script '{label}' contains marker '{marker}', cannot safely upload"
295+ format!("Script '{label}' contains marker '{marker}', cannot safely upload").into(),
292 Ok(command)
298 Ok(command)
@@ -351,12 +357,6 @@ enum WaitResult {
354−#[derive(PartialEq, Eq)]
360pub enum VmInput {
360pub enum VmInput {
361 Bytes(Vec<u8>),
361 Bytes(Vec<u8>),
362 Shutdown,
362 Shutdown,
@@ -364,7 +364,6 @@ pub enum VmInput {
365enum VmOutput {
365enum VmOutput {
366 LoginActionTimeout { action: String, timeout: Duration },
366 LoginActionTimeout { action: String, timeout: Duration },
367− LoginActionFailed { action: String, reason: String },
370#[derive(Default)]
369#[derive(Default)]
@@ -401,41 +400,6 @@ impl OutputMonitor {
401 WaitResult::Found
400 WaitResult::Found
405− fn wait_for_any(&self, needles: &[&str], timeout: Duration) -> WaitAnyResult {
406− let mut found: Option<usize> = None;
407− let (_unused, timeout_result) = self
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();
420− if timeout_result.timed_out() {
421− WaitAnyResult::Timeout
423− WaitAnyResult::Found(found.unwrap_or(0))
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);
441#[derive(Debug)]
405#[derive(Debug)]
@@ -484,16 +448,18 @@ impl IoControl {
484fn ensure_base_image(
448fn ensure_base_image(
485 base_raw: &Path,
449 base_raw: &Path,
486 base_compressed: &Path,
450 base_compressed: &Path,
487− status: Option<&StatusEmitter<'_>>,
451+ status: Option<&StatusFile>,
488−) -> Result<()> {
452+) -> Result<(), Box<dyn std::error::Error>> {
489 if base_raw.exists() {
453 if base_raw.exists() {
490 return Ok(());
454 return Ok(());
493 if !base_compressed.exists()
457 if !base_compressed.exists()
494− || fs::metadata(base_compressed).map(|m| m.len())? < DEBIAN_COMPRESSED_SIZE_BYTES
458+ || std::fs::metadata(base_compressed).map(|m| m.len())? < DEBIAN_COMPRESSED_SIZE_BYTES
460+ if let Some(status) = status {
496− emit_status(status, "downloading base image...");
461+ status.update("downloading base image...");
497 tracing::info!("downloading base image");
463 tracing::info!("downloading base image");
498 let status = Command::new("curl")
464 let status = Command::new("curl")
@@ -508,14 +474,15 @@ fn ensure_base_image(
509 .status()?;
475 .status()?;
510 if !status.success() {
476 if !status.success() {
511− bail!("failed to download base image");
477+ return Err("Failed to download base image".into());
515 // Check SHA
481 // Check SHA
517− emit_status(status, "verifying base image...");
483+ if let Some(status) = status {
518− tracing::info!("verifying base image...");
484+ status.update("verifying base image...");
519 let input = format!("{} {}\n", DEBIAN_COMPRESSED_SHA, base_compressed.display());
486 let input = format!("{} {}\n", DEBIAN_COMPRESSED_SHA, base_compressed.display());
521 let mut child = Command::new("/usr/bin/shasum")
488 let mut child = Command::new("/usr/bin/shasum")
@@ -533,25 +500,25 @@ fn ensure_base_image(
534 let status = child.wait().expect("failed to wait on child");
501 let status = child.wait().expect("failed to wait on child");
535 if !status.success() {
502 if !status.success() {
537− "SHA validation failed for {DEBIAN_COMPRESSED_DISK_URL}"
503+ return Err(format!("SHA validation failed for {DEBIAN_COMPRESSED_DISK_URL}").into());
507+ if let Some(status) = status {
542− emit_status(status, "decompressing base image...");
508+ status.update("decompressing base image...");
543− tracing::info!("decompressing base image...");
510+ tracing::info!("decompressing base image");
544 let status = Command::new("tar")
511 let status = Command::new("tar")
547 &base_compressed.to_string_lossy(),
514 &base_compressed.to_string_lossy(),
548 BASE_DISK_RAW_NAME,
515 BASE_DISK_RAW_NAME,
550− .stdout(fs::File::create(base_raw)?)
517+ .stdout(std::fs::File::create(base_raw)?)
551 .status()?;
518 .status()?;
553 if !status.success() {
520 if !status.success() {
554− bail!("Failed to decompress base image");
521+ return Err("Failed to decompress base image".into());
@@ -562,56 +529,29 @@ fn ensure_default_image(
562 base_compressed: &Path,
529 base_compressed: &Path,
563 default_raw: &Path,
530 default_raw: &Path,
564 directory_shares: &[DirectoryShare],
531 directory_shares: &[DirectoryShare],
565− provision_log: Option<&Path>,
566− status: Option<&StatusEmitter<'_>>,
532+ status: Option<&StatusFile>,
567−) -> Result<()> {
533+) -> Result<(), Box<dyn std::error::Error>> {
568 if default_raw.exists() {
534 if default_raw.exists() {
569 return Ok(());
535 return Ok(());
572 ensure_base_image(base_raw, base_compressed, status)?;
538 ensure_base_image(base_raw, base_compressed, status)?;
540+ if let Some(status) = status {
574− emit_status(status, "configuring base image...");
541+ status.update("configuring base image...");
575− tracing::info!("configuring base image...");
543+ tracing::info!("configuring base image");
576 fs::copy(base_raw, default_raw)?;
544 fs::copy(base_raw, default_raw)?;
578− let provision_command = script_command_from_content("provision.sh", PROVISION_SCRIPT)?;
546+ let provision_command = script_command_from_content(PROVISION_SCRIPT_NAME, PROVISION_SCRIPT)?;
579− let provision_actions = [
547+ run_vm(
580− Send(provision_command),
549+ &[Send(provision_command)],
582− success: "VIBEBOX_PROVISION_OK".to_string(),
583− failure: "VIBEBOX_PROVISION_FAILED".to_string(),
584− timeout: PROVISION_EXPECT_TIMEOUT,
587− let provision_result = if let Some(log_path) = provision_log {
588− let log_path = log_path.to_path_buf();
592− directory_shares,
550+ directory_shares,
593− BoxConfig::default().cpu_count,
551+ DEFAULT_CPU_COUNT,
594− BoxConfig::default().ram_size.as_u64(),
552+ DEFAULT_RAM_BYTES,
596− move |output_monitor, vm_output_fd, vm_input_fd| {
554+ )?;
597− spawn_vm_io_with_log(output_monitor, vm_output_fd, vm_input_fd, log_path)
605− BoxConfig::default().cpu_count,
606− BoxConfig::default().ram_size.as_u64(),
611− if let Err(err) = provision_result {
612− let _ = fs::remove_file(default_raw);
@@ -619,47 +559,19 @@ fn ensure_default_image(
619fn ensure_instance_disk(
559fn ensure_instance_disk(
620 instance_raw: &Path,
560 instance_raw: &Path,
621 template_raw: &Path,
561 template_raw: &Path,
622− target_bytes: ByteSize,
623− status: Option<&StatusEmitter<'_>>,
562+ status: Option<&StatusFile>,
624−) -> Result<bool> {
563+) -> Result<(), Box<dyn std::error::Error>> {
625 if instance_raw.exists() {
564 if instance_raw.exists() {
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;
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.",
636− return Ok(false);
565+ return Ok(());
639− let template_size = ByteSize(fs::metadata(template_raw)?.len());
568+ if let Some(status) = status {
640− if target_bytes < template_size {
569+ status.update("creating instance disk...");
642− "Requested disk size {} is smaller than base image size {}",
643− target_bytes, template_size
646− let target_size = target_bytes;
647− let needs_resize = target_size > template_size;
649− emit_status(status, "creating instance disk...");
650− tracing::info!("creating instance disk...");
651 tracing::info!(path = %template_raw.display(), "creating instance disk");
571 tracing::info!(path = %template_raw.display(), "creating instance disk");
652− fs::create_dir_all(instance_raw.parent().unwrap())?;
572+ std::fs::create_dir_all(instance_raw.parent().unwrap())?;
653− if target_size == template_size {
654− fs::copy(template_raw, instance_raw)?;
573+ fs::copy(template_raw, instance_raw)?;
655− return Ok(needs_resize);
574+ Ok(())
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)?;
665pub struct IoContext {
577pub struct IoContext {
@@ -675,17 +587,18 @@ pub fn create_pipe() -> (OwnedFd, OwnedFd) {
675 (read_stream.into(), write_stream.into())
587 (read_stream.into(), write_stream.into())
678−pub fn spawn_vm_io_with_hooks<
590+pub fn spawn_vm_io_with_hooks<F, G>(
679− F: FnMut(&str) -> bool + std::marker::Send + 'static,
680− G: FnMut(&[u8]) + std::marker::Send + 'static,
682 output_monitor: Arc<OutputMonitor>,
591 output_monitor: Arc<OutputMonitor>,
683 vm_output_fd: OwnedFd,
592 vm_output_fd: OwnedFd,
684 vm_input_fd: OwnedFd,
593 vm_input_fd: OwnedFd,
685 io_control: Arc<IoControl>,
594 io_control: Arc<IoControl>,
686 mut on_line: F,
595 mut on_line: F,
687 mut on_output: G,
596 mut on_output: G,
688−) -> IoContext {
597+) -> IoContext
599+ F: FnMut(&str) -> bool + ::std::marker::Send + 'static,
600+ G: FnMut(&[u8]) + ::std::marker::Send + 'static,
689 let (input_tx, input_rx): (Sender<VmInput>, Receiver<VmInput>) = mpsc::channel();
602 let (input_tx, input_rx): (Sender<VmInput>, Receiver<VmInput>) = mpsc::channel();
691 // raw_guard is set when we've put the user's terminal into raw mode because we've attached stdin/stdout to the VM.
604 // raw_guard is set when we've put the user's terminal into raw mode because we've attached stdin/stdout to the VM.
@@ -833,14 +746,14 @@ pub fn spawn_vm_io_with_hooks<
833 PollResult::Spurious => continue,
746 PollResult::Spurious => continue,
834 PollResult::Ready(bytes) => {
747 PollResult::Ready(bytes) => {
835 if io_control.forward_output() {
748 if io_control.forward_output() {
836− // enable raw mode if we haven't already
749+ // enable raw mode, if we haven't already
837 if raw_guard.lock().unwrap().is_none()
750 if raw_guard.lock().unwrap().is_none()
838 && let Ok(guard) = enable_raw_mode(libc::STDIN_FILENO)
751 && let Ok(guard) = enable_raw_mode(libc::STDIN_FILENO)
840 *raw_guard.lock().unwrap() = Some(guard);
753 *raw_guard.lock().unwrap() = Some(guard);
843− let mut stdout = io::stdout().lock();
756+ let mut stdout = std::io::stdout().lock();
844 if stdout.write_all(bytes).is_err() {
757 if stdout.write_all(bytes).is_err() {
@@ -856,7 +769,7 @@ pub fn spawn_vm_io_with_hooks<
857 // Copies data from mpsc channel into VM, so vibe can "type" stuff and run scripts.
770 // Copies data from mpsc channel into VM, so vibe can "type" stuff and run scripts.
858 let mux_thread = thread::spawn(move || {
771 let mux_thread = thread::spawn(move || {
859− let mut vm_writer = fs::File::from(vm_input_fd);
772+ let mut vm_writer = std::fs::File::from(vm_input_fd);
861 match input_rx.recv() {
774 match input_rx.recv() {
862 Ok(VmInput::Bytes(data)) => {
775 Ok(VmInput::Bytes(data)) => {
@@ -886,7 +799,7 @@ pub fn spawn_vm_io_with_line_handler<F>(
886 on_line: F,
799 on_line: F,
887) -> IoContext
800) -> IoContext
889− F: FnMut(&str) -> bool + std::marker::Send + 'static,
802+ F: FnMut(&str) -> bool + ::std::marker::Send + 'static,
891 spawn_vm_io_with_hooks(
804 spawn_vm_io_with_hooks(
892 output_monitor,
805 output_monitor,
@@ -906,36 +819,6 @@ pub fn spawn_vm_io(
906 spawn_vm_io_with_line_handler(output_monitor, vm_output_fd, vm_input_fd, |_| false)
819 spawn_vm_io_with_line_handler(output_monitor, vm_output_fd, vm_input_fd, |_| false)
909−fn spawn_vm_io_with_log(
910− output_monitor: Arc<OutputMonitor>,
911− vm_output_fd: OwnedFd,
912− vm_input_fd: OwnedFd,
915− let log_file = fs::OpenOptions::new()
921− .map(|file| Arc::new(Mutex::new(file)));
923− spawn_vm_io_with_hooks(
930− if let Some(log) = &log_file
931− && let Ok(mut file) = log.lock()
933− let _ = file.write_all(bytes);
939impl IoContext {
822impl IoContext {
940 pub fn shutdown(self) {
823 pub fn shutdown(self) {
941 let _ = self.input_tx.send(VmInput::Shutdown);
824 let _ = self.input_tx.send(VmInput::Shutdown);
@@ -953,7 +836,7 @@ fn create_vm_configuration(
953 vm_writes_to_fd: OwnedFd,
836 vm_writes_to_fd: OwnedFd,
954 cpu_count: usize,
837 cpu_count: usize,
955 ram_bytes: u64,
838 ram_bytes: u64,
956−) -> Result<Retained<VZVirtualMachineConfiguration>> {
839+) -> Result<Retained<VZVirtualMachineConfiguration>, Box<dyn std::error::Error>> {
958 let platform =
841 let platform =
959 VZGenericPlatformConfiguration::init(VZGenericPlatformConfiguration::alloc());
842 VZGenericPlatformConfiguration::init(VZGenericPlatformConfiguration::alloc());
@@ -987,7 +870,7 @@ fn create_vm_configuration(
988 VZDiskImageCachingMode::Automatic,
871 VZDiskImageCachingMode::Automatic,
989 VZDiskImageSynchronizationMode::Full,
872 VZDiskImageSynchronizationMode::Full,
992 let disk_device = VZVirtioBlockDeviceConfiguration::initWithAttachment(
875 let disk_device = VZVirtioBlockDeviceConfiguration::initWithAttachment(
993 VZVirtioBlockDeviceConfiguration::alloc(),
876 VZVirtioBlockDeviceConfiguration::alloc(),
@@ -1074,7 +957,7 @@ fn create_vm_configuration(
1074 // Validate
957 // Validate
1075 config.validateWithError().map_err(|e| {
958 config.validateWithError().map_err(|e| {
1076 io::Error::other(format!(
959 io::Error::other(format!(
1077− "invalid VM configuration: {:?}",
960+ "Invalid VM configuration: {:?}",
1078 e.localizedDescription()
961 e.localizedDescription()
@@ -1083,9 +966,9 @@ fn create_vm_configuration(
1086−fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>> {
969+fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>, Box<dyn std::error::Error>> {
1087 unsafe {
970 unsafe {
1088− let temp_dir = env::temp_dir();
971+ let temp_dir = std::env::temp_dir();
1089 let temp_path = temp_dir.join(format!("efi_variable_store_{}.efivars", std::process::id()));
972 let temp_path = temp_dir.join(format!("efi_variable_store_{}.efivars", std::process::id()));
1090 let url = nsurl_from_path(&temp_path)?;
973 let url = nsurl_from_path(&temp_path)?;
1091 let options = VZEFIVariableStoreInitializationOptions::AllowOverwrite;
974 let options = VZEFIVariableStoreInitializationOptions::AllowOverwrite;
@@ -1101,8 +984,8 @@ fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>> {
1101fn spawn_login_actions_thread(
984fn spawn_login_actions_thread(
1102 login_actions: Vec<LoginAction>,
985 login_actions: Vec<LoginAction>,
1103 output_monitor: Arc<OutputMonitor>,
986 output_monitor: Arc<OutputMonitor>,
1104− input_tx: Sender<VmInput>,
987+ input_tx: mpsc::Sender<VmInput>,
1105− vm_output_tx: Sender<VmOutput>,
988+ vm_output_tx: mpsc::Sender<VmOutput>,
1106) -> thread::JoinHandle<()> {
989) -> thread::JoinHandle<()> {
1107 thread::spawn(move || {
990 thread::spawn(move || {
1108 for a in login_actions {
991 for a in login_actions {
@@ -1116,27 +999,6 @@ fn spawn_login_actions_thread(
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),
1132− WaitAnyResult::Timeout => {
1133− let _ = vm_output_tx.send(VmOutput::LoginActionTimeout {
1134− action: format!("expect '{}'", success),
1140 Send(mut text) => {
1002 Send(mut text) => {
1141 text.push('\n'); // Type the newline so the command is actually submitted.
1003 text.push('\n'); // Type the newline so the command is actually submitted.
1142 input_tx.send(VmInput::Bytes(text.into_bytes())).unwrap();
1004 input_tx.send(VmInput::Bytes(text.into_bytes())).unwrap();
@@ -1152,9 +1014,9 @@ fn run_vm_with_io<F>(
1152 directory_shares: &[DirectoryShare],
1014 directory_shares: &[DirectoryShare],
1153 cpu_count: usize,
1015 cpu_count: usize,
1154 ram_bytes: u64,
1016 ram_bytes: u64,
1155− status: Option<&StatusEmitter<'_>>,
1017+ status: Option<&StatusFile>,
1156 io_handler: F,
1018 io_handler: F,
1157−) -> Result<()>
1019+) -> Result<(), Box<dyn std::error::Error>>
1159 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
1021 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,
@@ -1201,22 +1063,24 @@ where
1202 match rx.try_recv() {
1064 match rx.try_recv() {
1203 Ok(result) => {
1065 Ok(result) => {
1204− result.map_err(|e| Error::msg(format!("Failed to start VM: {}", e)))?;
1066+ result.map_err(|e| format!("Failed to start VM: {}", e))?;
1207 Err(mpsc::TryRecvError::Empty) => continue,
1069 Err(mpsc::TryRecvError::Empty) => continue,
1208 Err(mpsc::TryRecvError::Disconnected) => {
1070 Err(mpsc::TryRecvError::Disconnected) => {
1209− bail!("VM start channel disconnected");
1071+ return Err("VM start channel disconnected".into());
1214 if Instant::now() >= start_deadline {
1076 if Instant::now() >= start_deadline {
1215− bail!("Timed out waiting for VM to start");
1077+ return Err("Timed out waiting for VM to start".into());
1080+ if let Some(status) = status {
1218− emit_status(status, "vm booting... go vibecoder!");
1081+ status.update("vm booting... go vibecoder!");
1219− tracing::info!("vm booting... go vibecoder!");
1082+ status.clear();
1220 tracing::info!("vm booting");
1084 tracing::info!("vm booting");
1222 let output_monitor = Arc::new(OutputMonitor::default());
1086 let output_monitor = Arc::new(OutputMonitor::default());
@@ -1262,7 +1126,7 @@ where
1264 let mut last_state = None;
1128 let mut last_state = None;
1265− let mut exit_result: Result<(), String> = Ok(());
1129+ let mut exit_result = Ok(());
1267 unsafe {
1131 unsafe {
1268 NSRunLoop::mainRunLoop().runMode_beforeDate(
1132 NSRunLoop::mainRunLoop().runMode_beforeDate(
@@ -1281,24 +1145,8 @@ where
1281 exit_result = Err(format!(
1145 exit_result = Err(format!(
1282 "Login action ({}) timed out after {:?}; shutting down.",
1146 "Login action ({}) timed out after {:?}; shutting down.",
1283 action, timeout
1147 action, timeout
1286− if vm.canRequestStop() {
1287− if let Err(err) = vm.requestStopWithError() {
1288− tracing::error!(error = ?err, "failed to request VM stop");
1290− } else if vm.canStop() {
1291− let handler = RcBlock::new(|_error: *mut NSError| {});
1292− vm.stopWithCompletionHandler(&handler);
1297− Ok(VmOutput::LoginActionFailed { action, reason }) => {
1298− exit_result = Err(format!(
1299− "Login action ({}) failed: {}; shutting down.",
1302 unsafe {
1150 unsafe {
1303 if vm.canRequestStop() {
1151 if vm.canRequestStop() {
1304 if let Err(err) = vm.requestStopWithError() {
1152 if let Err(err) = vm.requestStopWithError() {
@@ -1314,7 +1162,7 @@ where
1314 Err(mpsc::TryRecvError::Empty) => {}
1162 Err(mpsc::TryRecvError::Empty) => {}
1315 Err(mpsc::TryRecvError::Disconnected) => {}
1163 Err(mpsc::TryRecvError::Disconnected) => {}
1317− if state != VZVirtualMachineState::Running {
1165+ if state != objc2_virtualization::VZVirtualMachineState::Running {
1318 //eprintln!("VM stopped with state: {:?}", state);
1166 //eprintln!("VM stopped with state: {:?}", state);
@@ -1324,7 +1172,7 @@ where
1325 io_ctx.shutdown();
1173 io_ctx.shutdown();
1327− exit_result.map_err(Error::msg)
1175+ exit_result
1330fn run_vm(
1178fn run_vm(
@@ -1333,8 +1181,8 @@ fn run_vm(
1333 directory_shares: &[DirectoryShare],
1181 directory_shares: &[DirectoryShare],
1334 cpu_count: usize,
1182 cpu_count: usize,
1335 ram_bytes: u64,
1183 ram_bytes: u64,
1336− status: Option<&StatusEmitter<'_>>,
1184+ status: Option<&StatusFile>,
1337−) -> Result<()> {
1185+) -> Result<(), Box<dyn std::error::Error>> {
1338 run_vm_with_io(
1186 run_vm_with_io(
1339 disk_path,
1187 disk_path,
1340 login_actions,
1188 login_actions,
@@ -1346,7 +1194,7 @@ fn run_vm(
1349−fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>> {
1197+fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>, Box<dyn std::error::Error>> {
1350 let abs_path = if path.is_absolute() {
1198 let abs_path = if path.is_absolute() {
1351 path.to_path_buf()
1199 path.to_path_buf()
1352 } else {
1200 } else {
@@ -1355,7 +1203,7 @@ fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>> {
1355 let ns_path = NSString::from_str(
1203 let ns_path = NSString::from_str(
1356 abs_path
1204 abs_path
1357 .to_str()
1205 .to_str()
1358− .with_context(|| "non-UTF8 path encountered while building NSURL")?,
1206+ .ok_or("Non-UTF8 path encountered while building NSURL")?,
1360 Ok(NSURL::fileURLWithPath(&ns_path))
1208 Ok(NSURL::fileURLWithPath(&ns_path))
@@ -1370,7 +1218,7 @@ fn enable_raw_mode(fd: i32) -> io::Result<RawModeGuard> {
1370 let original = attributes;
1218 let original = attributes;
1372 // Disable translation of carriage return to newline on input
1220 // Disable translation of carriage return to newline on input
1373− attributes.c_iflag &= !libc::ICRNL;
1221+ attributes.c_iflag &= !(libc::ICRNL);
1374 // Disable canonical mode (line buffering), echo, and signal generation
1222 // Disable canonical mode (line buffering), echo, and signal generation
1375 attributes.c_lflag &= !(libc::ICANON | libc::ECHO | libc::ISIG);
1223 attributes.c_lflag &= !(libc::ICANON | libc::ECHO | libc::ISIG);
1376 attributes.c_cc[libc::VMIN] = 0;
1224 attributes.c_cc[libc::VMIN] = 0;
@@ -1398,10 +1246,10 @@ impl Drop for RawModeGuard {
1399// Ensure the running binary has com.apple.security.virtualization entitlements by checking and, if not, signing and relaunching.
1247// Ensure the running binary has com.apple.security.virtualization entitlements by checking and, if not, signing and relaunching.
1400pub fn ensure_signed() {
1248pub fn ensure_signed() {
1401− if env::var("VIBEBOX_SKIP_CODESIGN").as_deref() == Ok("1") {
1249+ if std::env::var("VIBEBOX_SKIP_CODESIGN").as_deref() == Ok("1") {
1404− let exe = env::current_exe().expect("failed to get current exe path");
1252+ let exe = std::env::current_exe().expect("failed to get current exe path");
1405 let exe_str = exe.to_str().expect("exe path not valid utf-8");
1253 let exe_str = exe.to_str().expect("exe path not valid utf-8");
1407 let has_required_entitlements = {
1255 let has_required_entitlements = {
@@ -1423,8 +1271,8 @@ pub fn ensure_signed() {
1425 const ENTITLEMENTS: &str = include_str!("entitlements.plist");
1273 const ENTITLEMENTS: &str = include_str!("entitlements.plist");
1426− let entitlements_path = env::temp_dir().join("entitlements.plist");
1274+ let entitlements_path = std::env::temp_dir().join("entitlements.plist");
1427− fs::write(&entitlements_path, ENTITLEMENTS).expect("failed to write entitlements");
1275+ std::fs::write(&entitlements_path, ENTITLEMENTS).expect("failed to write entitlements");
1429 let output = Command::new("codesign")
1277 let output = Command::new("codesign")
@@ -1437,7 +1285,7 @@ pub fn ensure_signed() {
1438 .output();
1286 .output();
1440− let _ = fs::remove_file(&entitlements_path);
1288+ let _ = std::fs::remove_file(&entitlements_path);
1442 match output {
1290 match output {
1443 Ok(o) if o.status.success() => {
1291 Ok(o) if o.status.success() => {
@@ -1445,7 +1293,7 @@ pub fn ensure_signed() {
1445 if !stderr.trim().is_empty() {
1293 if !stderr.trim().is_empty() {
1446 tracing::debug!(codesign_stderr = %stderr.trim(), "codesign output");
1294 tracing::debug!(codesign_stderr = %stderr.trim(), "codesign output");
1448− let err = Command::new(&exe).args(env::args_os().skip(1)).exec();
1296+ let err = Command::new(&exe).args(std::env::args_os().skip(1)).exec();
1449 tracing::error!(error = %err, "failed to re-exec after signing");
1297 tracing::error!(error = %err, "failed to re-exec after signing");
1450 std::process::exit(1);
1298 std::process::exit(1);