b5cd1f2...main · vibebox

git.iko.soy/vibebox

17 files changed+1426−808

since splitsnapshots

unifiedsplit

Cargo.lock+18−1 Cargo.toml+3−1 docs/tasks.md+14−10 src/bin/vibebox-supervisor.rs+8−7 src/bin/vibebox.rs+53−95 src/config.rs+467−77 src/error_report.sh+28 src/explain.rs+32−47 src/instance.rs+289−154 src/lib.rs+1 src/provision.sh+7−7 src/session_manager.rs+56−93 src/ssh.sh+18−10 src/tui.rs+31−31 src/utils.rs+18 src/vm.rs+179−161 src/vm_manager.rs+204−114

Cargo.lock+18−1

@@ -82,6 +82,12 @@ dependencies = [

8282 "windows-sys 0.61.2",

8383]

8484

85+[[package]]

86+name = "anyhow"

87+version = "1.0.101"

88+source = "registry+https://github.com/rust-lang/crates.io-index"

89+checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"

90+

8591[[package]]

8692name = "assert_cmd"

8793version = "2.1.2"

@@ -144,6 +150,15 @@ version = "3.19.1"

144150source = "registry+https://github.com/rust-lang/crates.io-index"

145151checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"

146152

153+[[package]]

154+name = "bytesize"

155+version = "2.3.1"

156+source = "registry+https://github.com/rust-lang/crates.io-index"

157+checksum = "6bd91ee7b2422bcb158d90ef4d14f75ef67f340943fc4149891dcce8f8b972a3"

158+dependencies = [

159+ "serde_core",

160+]

161+

147162[[package]]

148163name = "cassowary"

149164version = "0.3.0"

@@ -1303,10 +1318,12 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"

13031318

13041319[[package]]

13051320name = "vibebox"

1306−version = "0.2.4"

1321+version = "0.3.2"

13071322dependencies = [

1323+ "anyhow",

13081324 "assert_cmd",

13091325 "block2",

1326+ "bytesize",

13101327 "clap",

13111328 "color-eyre",

13121329 "crossterm",

Cargo.toml+3−1

@@ -1,6 +1,6 @@

11[package]

22name = "vibebox"

3−version = "0.2.4"

3+version = "0.3.2"

44edition = "2024"

55authors = ["Finn Sheng"]

66description = "Ultrafast CLI on Apple Silicon macOS for fast, sandboxed development and LLM agents."

@@ -42,6 +42,8 @@ ratatui = { version = "0.29.0", features = ["unstable-rendered-line-info"] }

4242tracing = "0.1"

4343tracing-subscriber = { version = "0.3", features = ["env-filter"] }

4444dialoguer = "0.12.0"

45+bytesize = {version = "2.3.1",features = ["serde"]}

46+anyhow = "1.0.101"

4547

4648[dev-dependencies]

4749assert_cmd = "2"

docs/tasks.md+14−10

@@ -25,7 +25,7 @@

25255. [x] Implement rendering functions for header, terminal area, input area, completions, and status bar.

26266. [x] Implement async event loop (keyboard, resize, tick) with crossterm EventStream + tokio.

27277. [x] Add a standalone TUI CLI binary (no main.rs wiring) with placeholder VM info and TODOs for VM integration.

28−8. [ ] Run tests and validate coverage for the new module.

28+8. [x] Run tests and validate coverage for the new module.

2929

3030## TUI

3131

@@ -49,19 +49,23 @@

4949 4. [x] set up the cli.

50509. [x] fix ui overlap, and consistency issue.

515110. [x] `purge-cache` to clear the cache.

52−11. [ ] intensive integration test.

52+11. [x] intensive integration test.

5353

5454## Publish

5555

56−1. [ ] write the docs.

57−2. [ ] setup quick install link.

58−3. [ ] setup website.

56+1. [x] write the docs.

57+2. [x] setup quick install link.

58+3. [x] setup website.

5959

6060## Stage 2

6161

62621. [ ] retouch the cli ux.

63−2. [ ] refactor the code.

64−3. [ ] Redirect vm output to log.

65−4. [ ] Redirect vm output to vibebox starting it.

66−5. [ ] use anyhow to sync api.

67−6. [ ] add support for ipv6.

63+2. [x] refactor the code.

64+3. [ ] refactor the mount system.

65+4. [x] refactor the vm process lifetime.

66+5. [x] Redirect vm output to log.

67+6. [x] Redirect vm output to vibebox starting it.

68+7. [x] use anyhow to sync api.

69+8. [ ] add support for ipv6.

70+9. [x] use UnixStream instead of status file

71+10. [x] liveness check should also happen when waiting for ssh port

src/bin/vibebox-supervisor.rs+8−7

@@ -21,15 +21,16 @@ fn main() -> Result<()> {

2121 color_eyre::install()?;

2222

2323 tracing::info!("starting vm supervisor");

24− let cwd = env::current_dir().map_err(|err| color_eyre::eyre::eyre!(err.to_string()))?;

25− let config = config::load_config(&cwd);

26− let instance_dir = instance::ensure_instance_dir(&cwd)

24+ let project_dir = env::current_dir().map_err(|err| color_eyre::eyre::eyre!(err.to_string()))?;

25+ let config = config::load_config(&project_dir)

2726 .map_err(|err| color_eyre::eyre::eyre!(err.to_string()))?;

28− let _ = instance::touch_last_active(&instance_dir);

27+ let _ = instance::ensure_instance_dir(&project_dir)

28+ .map_err(|err| color_eyre::eyre::eyre!(err.to_string()))?;

29+ let _ = instance::touch_last_active(&project_dir);

2930 let args = vm::VmArg {

3031 cpu_count: config.box_cfg.cpu_count,

31− ram_bytes: config.box_cfg.ram_mb.saturating_mul(1024 * 1024),

32− disk_bytes: config.box_cfg.disk_gb.saturating_mul(1024 * 1024 * 1024),

32+ ram_bytes: config.box_cfg.ram_size.as_u64(),

33+ disk_bytes: config.box_cfg.disk_size.as_u64(),

3334 no_default_mounts: false,

3435 mounts: config.box_cfg.mounts.clone(),

3536 };

@@ -37,7 +38,7 @@ fn main() -> Result<()> {

3738 tracing::info!(auto_shutdown_ms, "vm supervisor config");

3839

3940 let result = vm_manager::run_manager(args, auto_shutdown_ms);

40− let _ = instance::touch_last_active(&instance_dir);

41+ let _ = instance::touch_last_active(&project_dir);

4142 if let Err(err) = result {

4243 tracing::error!(error = %err, "vm supervisor exited");

4344 return Err(color_eyre::eyre::eyre!(err.to_string()));

src/bin/vibebox.rs+53−95

@@ -1,3 +1,7 @@

1+use bytesize::ByteSize;

2+use clap::Parser;

3+use color_eyre::Result;

4+use dialoguer::Confirm;

15use std::{

26 env,

37 ffi::OsString,

@@ -6,10 +10,6 @@ use std::{

610 path::{Path, PathBuf},

711 sync::{Arc, Mutex},

812};

9−

10−use clap::Parser;

11−use color_eyre::Result;

12−use dialoguer::Confirm;

1313use time::OffsetDateTime;

1414use time::format_description::well_known::Rfc3339;

1515use tracing_subscriber::filter::LevelFilter;

@@ -17,8 +17,9 @@ use tracing_subscriber::registry::Registry;

1717use tracing_subscriber::{EnvFilter, fmt, prelude::*, reload};

1818

1919use vibebox::tui::{AppState, VmInfo};

20+use vibebox::utils::relative_to_home;

2021use vibebox::{

21− SessionManager, commands, config, explain, instance, session_manager, tui, vm, vm_manager,

22+ SessionManager, commands, config, explain, instance, session_manager, tui, vm_manager,

2223};

2324

2425#[derive(Debug, Parser)]

@@ -56,53 +57,26 @@ fn main() -> Result<()> {

5657

5758 let config_override = cli.config.clone();

5859 let raw_args: Vec<OsString> = env::args_os().collect();

59− let config = config::load_config_with_path(&cwd, config_override.as_deref());

60+ let config = config::load_config_with_path(&cwd, config_override.as_deref())

61+ .map_err(|err| color_eyre::eyre::eyre!(err.to_string()))?;

6062

61− if env::var("VIBEBOX_VM_MANAGER").as_deref() == Ok("1") {

62− tracing::info!("starting vm manager mode");

63− let args = vm::VmArg {

64− cpu_count: config.box_cfg.cpu_count,

65− ram_bytes: config.box_cfg.ram_mb.saturating_mul(1024 * 1024),

66− disk_bytes: config.box_cfg.disk_gb.saturating_mul(1024 * 1024 * 1024),

67− no_default_mounts: false,

68− mounts: config.box_cfg.mounts.clone(),

69− };

70− let auto_shutdown_ms = config.supervisor.auto_shutdown_ms;

71− tracing::info!(auto_shutdown_ms, "vm manager config");

72− if let Err(err) = vm_manager::run_manager(args, auto_shutdown_ms) {

73− tracing::error!(error = %err, "vm manager exited");

74− return Err(color_eyre::eyre::eyre!(err.to_string()));

75− }

76− return Ok(());

77− }

78−

79− vm::ensure_signed();

80−

81− let vm_args = vm::VmArg {

82− cpu_count: config.box_cfg.cpu_count,

83− ram_bytes: config.box_cfg.ram_mb.saturating_mul(1024 * 1024),

84− disk_bytes: config.box_cfg.disk_gb.saturating_mul(1024 * 1024 * 1024),

85− no_default_mounts: false,

86− mounts: config.box_cfg.mounts.clone(),

87− };

88− let auto_shutdown_ms = config.supervisor.auto_shutdown_ms;

8963 let vm_info = VmInfo {

90− max_memory_mb: vm_args.ram_bytes / (1024 * 1024),

91− cpu_cores: vm_args.cpu_count,

92− max_disk_gb: (vm_args.disk_bytes as f32) / 1024.0 / 1024.0 / 1024.0,

64+ max_memory: config.box_cfg.ram_size,

65+ cpu_cores: config.box_cfg.cpu_count,

66+ max_disk: config.box_cfg.disk_size,

9367 system_name: "Debian".to_string(), // TODO: read system name from the VM.

94− auto_shutdown_ms,

68+ auto_shutdown_ms: config.supervisor.auto_shutdown_ms,

9569 };

9670 if let Ok(manager) = SessionManager::new() {

9771 if let Err(err) = manager.update_global_sessions(&cwd) {

9872 tracing::warn!(error = %err, "failed to update a global session list");

9973 }

10074 } else {

101− tracing::warn!("failed to initialize session manager");

75+ tracing::error!("failed to initialize session manager");

76+ std::process::exit(1);

10277 }

10378 let commands = commands::build_commands();

10479 let app = Arc::new(Mutex::new(AppState::new(cwd.clone(), vm_info, commands)));

105−

10680 {

10781 let mut locked = app.lock().expect("app state poisoned");

10882 tui::render_tui_once(&mut locked)?;

@@ -112,24 +86,40 @@ fn main() -> Result<()> {

11286 writeln!(stdout)?;

11387 stdout.flush()?;

11488 }

115− warn_disk_size_mismatch(&cwd, vm_args.disk_bytes);

89+ warn_disk_size_mismatch(&cwd, config.box_cfg.disk_size);

11690 if let Some(handle) = stderr_handle {

11791 let _ = handle.modify(|filter| *filter = LevelFilter::INFO);

11892 }

11993

120− tracing::debug!(auto_shutdown_ms, "auto shutdown config");

121− let manager_conn =

122− vm_manager::ensure_manager(&raw_args, auto_shutdown_ms, config_override.as_deref())

123− .map_err(|err| {

124− tracing::error!(error = %err, "failed to ensure vm manager");

125− color_eyre::eyre::eyre!(err.to_string())

126− })?;

127−

128− instance::run_with_ssh(manager_conn).map_err(|err| {

94+ tracing::debug!(config.supervisor.auto_shutdown_ms, "auto shutdown config");

95+ let manager_conn = vm_manager::ensure_manager(

96+ &raw_args,

97+ config.supervisor.auto_shutdown_ms,

98+ config_override.as_deref(),

99+ )

100+ .map_err(|err| {

129101 tracing::error!(error = %err, "failed to ensure vm manager");

130102 color_eyre::eyre::eyre!(err.to_string())

131103 })?;

132104

105+ if let Err(err) = instance::run_with_ssh(manager_conn) {

106+ if let Some(instance::InstanceError::UnexpectedDisconnection) =

107+ err.downcast_ref::<instance::InstanceError>()

108+ {

109+ tracing::warn!("vm manager disconnected; exiting vibebox");

110+ } else if let Some(instance::InstanceError::VMError(vm_error)) =

111+ err.downcast_ref::<instance::InstanceError>()

112+ {

113+ tracing::error!("[vm]: {vm_error}");

114+ tracing::info!("vibecoding paused: the VM says today is a rest day 😴");

115+ std::process::exit(1);

116+ } else {

117+ let message = err.to_string();

118+ tracing::error!(error = %message, "vibebox exited: uncaught error");

119+ return Err(color_eyre::eyre::eyre!(message));

120+ }

121+ }

122+

133123 tracing::info!("See you again — keep vibecoding (no SEVs, only vibes) 😈");

134124

135125 Ok(())

@@ -211,13 +201,14 @@ fn handle_command(command: Command, cwd: &Path, config_override: Option<&Path>)

211201 "Purged {} file{} totaling {} from {}",

212202 file_count,

213203 if file_count == 1 { "" } else { "s" },

214− format_bytes(total_bytes),

204+ ByteSize(total_bytes),

215205 cache_dir.display()

216206 );

217207 Ok(())

218208 }

219209 Command::Explain => {

220− let config = config::load_config_with_path(cwd, config_override);

210+ let config = config::load_config_with_path(cwd, config_override)

211+ .map_err(|err| color_eyre::eyre::eyre!(err.to_string()))?;

221212 let mounts = explain::build_mount_rows(cwd, &config)

222213 .map_err(|err| color_eyre::eyre::eyre!(err.to_string()))?;

223214 let networks = explain::build_network_rows(cwd)

@@ -240,20 +231,6 @@ fn project_name(directory: &Path) -> String {

240231 .to_string()

241232}

242233

243−fn relative_to_home(directory: &Path) -> String {

244− let Ok(home) = env::var("HOME") else {

245− return directory.display().to_string();

246− };

247− let home_path = PathBuf::from(home);

248− if let Ok(stripped) = directory.strip_prefix(&home_path) {

249− if stripped.components().next().is_none() {

250− return "~".to_string();

251− }

252− return format!("~/{}", stripped.display());

253− }

254− directory.display().to_string()

255−}

256−

257234fn cache_dir() -> Result<PathBuf> {

258235 let home = env::var("HOME").map(PathBuf::from)?;

259236 let cache_home = env::var("XDG_CACHE_HOME")

@@ -302,23 +279,6 @@ fn measure_dir(path: &Path) -> Result<(u64, u64)> {

302279 Ok((file_count, total_bytes))

303280}

304281

305−fn format_bytes(bytes: u64) -> String {

306− const KB: f64 = 1024.0;

307− const MB: f64 = KB * 1024.0;

308− const GB: f64 = MB * 1024.0;

309−

310− let b = bytes as f64;

311− if b >= GB {

312− format!("{:.2} GB", b / GB)

313− } else if b >= MB {

314− format!("{:.1} MB", b / MB)

315− } else if b >= KB {

316− format!("{:.1} KB", b / KB)

317− } else {

318− format!("{} B", bytes)

319− }

320−}

321−

322282fn format_last_active(value: Option<&str>) -> String {

323283 let Some(raw) = value else {

324284 return "-".to_string();

@@ -360,24 +320,22 @@ fn format_last_active(value: Option<&str>) -> String {

360320 format!("{} day{} ago", days, if days == 1 { "" } else { "s" })

361321}

362322

363−fn warn_disk_size_mismatch(cwd: &Path, configured_bytes: u64) {

323+fn warn_disk_size_mismatch(cwd: &Path, configured_size: ByteSize) {

364324 let instance_raw = cwd

365325 .join(session_manager::INSTANCE_DIR_NAME)

366326 .join("instance.raw");

367327 let Ok(meta) = fs::metadata(&instance_raw) else {

368328 return;

369329 };

370− let current_bytes = meta.len();

371− if current_bytes == configured_bytes {

330+ let current_size = ByteSize::b(meta.len());

331+ if current_size == configured_size {

372332 return;

373333 }

374− let current_gb = current_bytes as f64 / (1024.0 * 1024.0 * 1024.0);

375− let target_gb = configured_bytes as f64 / (1024.0 * 1024.0 * 1024.0);

376334 tracing::warn!(

377− "instance disk size does not match config (current {:.2} GB, config {:.2} GB). \

335+ "instance disk size does not match config (current {}, config {}). \

378336disk_gb applies only on init. Run `vibebox reset` to recreate or set disk_gb to match; using the existing disk.",

379− current_gb,

380− target_gb

337+ current_size,

338+ configured_size,

381339 );

382340}

383341

@@ -386,13 +344,13 @@ type StderrHandle = reload::Handle<LevelFilter, Registry>;

386344fn init_tracing(cwd: &Path) -> Option<StderrHandle> {

387345 let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("debug"));

388346 let file_filter = filter.clone();

389− let stderr_is_tty = std::io::stderr().is_terminal();

347+ let stderr_is_tty = io::stderr().is_terminal();

390348 let ansi = stderr_is_tty && env::var("VIBEBOX_LOG_NO_COLOR").is_err();

391349 let file = instance::ensure_instance_dir(cwd)

392350 .ok()

393351 .and_then(|instance_dir| {

394352 let log_path = instance_dir.join("cli.log");

395− std::fs::OpenOptions::new()

353+ fs::OpenOptions::new()

396354 .create(true)

397355 .write(true)

398356 .truncate(true)

@@ -406,7 +364,7 @@ fn init_tracing(cwd: &Path) -> Option<StderrHandle> {

406364 .with_target(false)

407365 .with_ansi(ansi)

408366 .without_time()

409− .with_writer(std::io::stderr)

367+ .with_writer(io::stderr)

410368 .with_filter(stderr_filter);

411369 let subscriber = tracing_subscriber::registry().with(stderr_layer);

412370 if let Some(file) = file {

@@ -424,7 +382,7 @@ fn init_tracing(cwd: &Path) -> Option<StderrHandle> {

424382 let stderr_layer = fmt::layer()

425383 .with_target(false)

426384 .with_ansi(ansi)

427− .with_writer(std::io::stderr)

385+ .with_writer(io::stderr)

428386 .with_filter(filter);

429387 let subscriber = tracing_subscriber::registry().with(stderr_layer);

430388 if let Some(file) = file {

src/config.rs+467−77

@@ -1,13 +1,14 @@

1+use anyhow::{Context, Error, Result, bail};

2+use bytesize::ByteSize;

3+use serde::{Deserialize, Serialize};

14use std::{

25 env, fs, io,

36 path::{Path, PathBuf},

47};

6−use serde::{Deserialize, Serialize};

7−

89use crate::vm::DirectoryShare;

910

10−pub const CONFIG_FILENAME: &str = "vibebox.toml";

11+const CONFIG_FILENAME: &str = "vibebox.toml";

1112pub const CONFIG_PATH_ENV: &str = "VIBEBOX_CONFIG_PATH";

1213

1314const DEFAULT_CPU_COUNT: usize = 2;

@@ -22,20 +23,83 @@ pub struct Config {

2223 pub supervisor: SupervisorConfig,

2324}

2425

26+const MI_B: u64 = 1024 * 1024;

27+const GI_B: u64 = 1024 * 1024 * 1024;

28+

29+mod serde_mb {

30+ use super::{ByteSize, MI_B};

31+ use serde::{Deserialize, Deserializer, Serializer};

32+

33+ pub fn serialize<S>(v: &ByteSize, s: S) -> Result<S::Ok, S::Error>

34+ where

35+ S: Serializer,

36+ {

37+ let bytes = v.0;

38+ if !bytes.is_multiple_of(MI_B) {

39+ return Err(serde::ser::Error::custom(

40+ "ram_mb must be an integer number of MB",

41+ ));

42+ }

43+ s.serialize_u64(bytes / MI_B)

44+ }

45+

46+ pub fn deserialize<'de, D>(d: D) -> Result<ByteSize, D::Error>

47+ where

48+ D: Deserializer<'de>,

49+ {

50+ let mb = u64::deserialize(d)?;

51+ let bytes = mb

52+ .checked_mul(MI_B)

53+ .ok_or_else(|| serde::de::Error::custom("ram_mb overflow"))?;

54+ Ok(ByteSize(bytes))

55+ }

56+}

57+

58+mod serde_gb {

59+ use super::{ByteSize, GI_B};

60+ use serde::{Deserialize, Deserializer, Serializer};

61+

62+ pub fn serialize<S>(v: &ByteSize, s: S) -> Result<S::Ok, S::Error>

63+ where

64+ S: Serializer,

65+ {

66+ let bytes = v.0;

67+ if !bytes.is_multiple_of(GI_B) {

68+ return Err(serde::ser::Error::custom(

69+ "disk_gb must be an integer number of GB",

70+ ));

71+ }

72+ s.serialize_u64(bytes / GI_B)

73+ }

74+

75+ pub fn deserialize<'de, D>(d: D) -> Result<ByteSize, D::Error>

76+ where

77+ D: Deserializer<'de>,

78+ {

79+ let gb = u64::deserialize(d)?;

80+ let bytes = gb

81+ .checked_mul(GI_B)

82+ .ok_or_else(|| serde::de::Error::custom("disk_gb overflow"))?;

83+ Ok(ByteSize(bytes))

84+ }

85+}

86+

2587#[derive(Debug, Clone, Serialize, Deserialize)]

2688pub struct BoxConfig {

2789 pub cpu_count: usize,

28− pub ram_mb: u64,

29− pub disk_gb: u64,

90+ #[serde(rename = "ram_mb", with = "serde_mb")]

91+ pub ram_size: ByteSize,

92+ #[serde(rename = "disk_gb", with = "serde_gb")]

93+ pub disk_size: ByteSize,

3094 pub mounts: Vec<String>,

3195}

3296

3397impl Default for BoxConfig {

3498 fn default() -> Self {

3599 Self {

36− cpu_count: default_cpu_count(),

37− ram_mb: default_ram_mb(),

38− disk_gb: default_disk_gb(),

100+ cpu_count: DEFAULT_CPU_COUNT,

101+ ram_size: ByteSize::mib(DEFAULT_RAM_MB),

102+ disk_size: ByteSize::gib(DEFAULT_DISK_GB),

39103 mounts: default_mounts(),

40104 }

41105 }

@@ -49,23 +113,11 @@ pub struct SupervisorConfig {

49113impl Default for SupervisorConfig {

50114 fn default() -> Self {

51115 Self {

52− auto_shutdown_ms: default_auto_shutdown_ms(),

116+ auto_shutdown_ms: DEFAULT_AUTO_SHUTDOWN_MS,

53117 }

54118 }

55119}

56120

57−fn default_cpu_count() -> usize {

58− DEFAULT_CPU_COUNT

59−}

60−

61−fn default_ram_mb() -> u64 {

62− DEFAULT_RAM_MB

63−}

64−

65−fn default_auto_shutdown_ms() -> u64 {

66− DEFAULT_AUTO_SHUTDOWN_MS

67−}

68−

69121fn default_mounts() -> Vec<String> {

70122 vec![

71123 "~/.codex:~/.codex:read-write".into(),

@@ -73,19 +125,12 @@ fn default_mounts() -> Vec<String> {

73125 ]

74126}

75127

76−fn default_disk_gb() -> u64 {

77− DEFAULT_DISK_GB

78−}

79−

80128pub fn config_path(project_root: &Path) -> PathBuf {

81129 project_root.join(CONFIG_FILENAME)

82130}

83131

84−pub fn ensure_config_file(

85− project_root: &Path,

86− override_path: Option<&Path>,

87−) -> Result<PathBuf, io::Error> {

88− let path = resolve_config_path(project_root, override_path);

132+pub fn ensure_config_file(project_root: &Path, override_path: Option<&Path>) -> Result<PathBuf> {

133+ let path = resolve_config_path(project_root, override_path)?;

89134 if !path.exists() {

90135 let default_config = Config::default();

91136 let contents = toml::to_string_pretty(&default_config).unwrap_or_default();

@@ -95,32 +140,24 @@ pub fn ensure_config_file(

95140 Ok(path)

96141}

97142

98−pub fn load_config(project_root: &Path) -> Config {

143+pub fn load_config(project_root: &Path) -> Result<Config> {

99144 load_config_with_path(project_root, None)

100145}

101146

102−pub fn load_config_with_path(project_root: &Path, override_path: Option<&Path>) -> Config {

103− let path = match ensure_config_file(project_root, override_path) {

104− Ok(path) => path,

105− Err(err) => die(&format!("failed to create config: {err}")),

106− };

107− let raw = match fs::read_to_string(&path) {

108− Ok(raw) => raw,

109− Err(err) => die(&format!("failed to read config: {err}")),

110− };

147+pub fn load_config_with_path(project_root: &Path, override_path: Option<&Path>) -> Result<Config> {

148+ let path =

149+ ensure_config_file(project_root, override_path).context("failed to create config")?;

150+ let raw = fs::read_to_string(&path).context("failed to read config")?;

111151 let trimmed = raw.trim();

112152 tracing::debug!(path = %path.display(), bytes = raw.len(), "loaded vibebox config");

113153 if trimmed.is_empty() {

114− die(&format!(

154+ bail!(format!(

115155 "config file ({}) is empty. Required fields: [box].cpu_count (integer), [box].ram_mb (integer), [box].disk_gb (integer), [box].mounts (array of strings), [supervisor].auto_shutdown_ms (integer)",

116156 path.display()

117157 ));

118158 }

119159

120− let value: toml::Value = match toml::from_str(trimmed) {

121− Ok(value) => value,

122− Err(err) => die(&format!("invalid config: {err}")),

123− };

160+ let value: toml::Value = toml::from_str(trimmed).context("invalid config")?;

124161 let schema_errors = validate_schema(&value);

125162 if !schema_errors.is_empty() {

126163 let message = format!(

@@ -128,27 +165,28 @@ pub fn load_config_with_path(project_root: &Path, override_path: Option<&Path>)

128165 path.display(),

129166 schema_errors.join("\n- ")

130167 );

131− die(&message);

168+ bail!(message);

132169 }

133170

134− let config: Config = match toml::from_str(trimmed) {

135− Ok(config) => config,

136− Err(err) => die(&format!("invalid config: {err}")),

137− };

138− validate_or_exit(&config);

139− config

171+ let config: Config = toml::from_str(trimmed).context("invalid config")?;

172+ validate_config(&config).map_err(Error::msg)?;

173+ Ok(config)

140174}

141175

142−fn resolve_config_path(project_root: &Path, override_path: Option<&Path>) -> PathBuf {

143− let root = match fs::canonicalize(project_root) {

144− Ok(root) => root,

145− Err(err) => die(&format!("failed to resolve project root: {err}")),

146− };

176+fn resolve_config_path(project_root: &Path, override_path: Option<&Path>) -> Result<PathBuf> {

177+ let env_override = env::var_os(CONFIG_PATH_ENV).map(PathBuf::from);

178+ resolve_config_path_inner(project_root, override_path, env_override)

179+}

147180

148− let override_path = override_path

149− .map(PathBuf::from)

150− .or_else(|| env::var_os(CONFIG_PATH_ENV).map(PathBuf::from));

151− let raw_path = if let Some(path) = override_path {

181+fn resolve_config_path_inner(

182+ project_root: &Path,

183+ override_path: Option<&Path>,

184+ env_override: Option<PathBuf>,

185+) -> Result<PathBuf> {

186+ let root = fs::canonicalize(project_root).context("failed to resolve project root")?;

187+

188+ let selected_path = override_path.map(PathBuf::from).or(env_override);

189+ let raw_path = if let Some(path) = selected_path {

152190 if path.is_absolute() {

153191 path

154192 } else {

@@ -159,14 +197,50 @@ fn resolve_config_path(project_root: &Path, override_path: Option<&Path>) -> Pat

159197 };

160198

161199 let normalized = normalize_path(&raw_path);

162− if !normalized.starts_with(&root) {

163− die(&format!(

200+ let resolved =

201+ resolve_path_for_boundary_check(&normalized).context("failed to resolve config path")?;

202+ if !resolved.starts_with(&root) {

203+ bail!(

164204 "config path must be within {}: {}",

165205 root.display(),

166− normalized.display()

167− ));

206+ resolved.display()

207+ );

168208 }

169− normalized

209+ Ok(normalized)

210+}

211+

212+fn resolve_path_for_boundary_check(path: &Path) -> Result<PathBuf, io::Error> {

213+ if path.exists() {

214+ return fs::canonicalize(path);

215+ }

216+ let (ancestor, missing) = nearest_existing_ancestor(path)?;

217+ let mut resolved = fs::canonicalize(ancestor)?;

218+ for part in missing {

219+ resolved.push(part);

220+ }

221+ Ok(resolved)

222+}

223+

224+fn nearest_existing_ancestor(path: &Path) -> Result<(&Path, Vec<std::ffi::OsString>), io::Error> {

225+ let mut current = path;

226+ let mut missing = Vec::new();

227+ while !current.exists() {

228+ let name = current.file_name().ok_or_else(|| {

229+ io::Error::new(

230+ io::ErrorKind::InvalidInput,

231+ format!("path has no existing ancestor: {}", path.display()),

232+ )

233+ })?;

234+ missing.push(name.to_os_string());

235+ current = current.parent().ok_or_else(|| {

236+ io::Error::new(

237+ io::ErrorKind::InvalidInput,

238+ format!("path has no parent: {}", path.display()),

239+ )

240+ })?;

241+ }

242+ missing.reverse();

243+ Ok((current, missing))

170244}

171245

172246fn normalize_path(path: &Path) -> PathBuf {

@@ -263,27 +337,343 @@ fn validate_string_array(

263337 }

264338}

265339

266−fn validate_or_exit(config: &Config) {

340+fn validate_config(config: &Config) -> Result<(), String> {

267341 if config.box_cfg.cpu_count == 0 {

268− die("box.cpu_count must be >= 1");

342+ return Err("box.cpu_count must be >= 1".to_string());

269343 }

270− if config.box_cfg.ram_mb == 0 {

271− die("box.ram_mb must be >= 1");

344+ if config.box_cfg.ram_size.as_mib() == 0.0 {

345+ return Err("box.ram_mb must be >= 1".to_string());

272346 }

273− if config.box_cfg.disk_gb == 0 {

274− die("box.disk_gb must be >= 1");

347+ if config.box_cfg.disk_size.as_gib() == 0.0 {

348+ return Err("box.disk_gb must be >= 1".to_string());

275349 }

276350 if config.supervisor.auto_shutdown_ms == 0 {

277− die("supervisor.auto_shutdown_ms must be >= 1");

351+ return Err("supervisor.auto_shutdown_ms must be >= 1".to_string());

278352 }

279353 for spec in &config.box_cfg.mounts {

280354 if let Err(err) = DirectoryShare::from_mount_spec(spec) {

281− die(&format!("invalid mount spec '{spec}': {err}"));

355+ return Err(format!("invalid mount spec '{spec}': {err}"));

282356 }

283357 }

358+ Ok(())

284359}

285360

286−fn die(message: &str) -> ! {

287− tracing::error!("{message}");

288− std::process::exit(1);

361+#[cfg(test)]

362+mod tests {

363+ use super::*;

364+ use std::ffi::OsString;

365+ use std::sync::Mutex;

366+ use tempfile::TempDir;

367+

368+ static ENV_MUTEX: Mutex<()> = Mutex::new(());

369+

370+ struct EnvGuard {

371+ key: &'static str,

372+ previous: Option<OsString>,

373+ }

374+

375+ impl EnvGuard {

376+ fn set(key: &'static str, value: &Path) -> Self {

377+ let previous = env::var_os(key);

378+ unsafe {

379+ env::set_var(key, value);

380+ }

381+ Self { key, previous }

382+ }

383+ }

384+

385+ impl Drop for EnvGuard {

386+ fn drop(&mut self) {

387+ match &self.previous {

388+ Some(value) => unsafe {

389+ env::set_var(self.key, value);

390+ },

391+ None => unsafe {

392+ env::remove_var(self.key);

393+ },

394+ }

395+ }

396+ }

397+

398+ #[test]

399+ fn default_config_serializes_with_legacy_keys() {

400+ let cfg = Config::default();

401+ let serialized = toml::to_string(&cfg).expect("default config should serialize");

402+

403+ assert!(serialized.contains("ram_mb = 2048"));

404+ assert!(serialized.contains("disk_gb = 5"));

405+ assert!(!serialized.contains("ram_size"));

406+ assert!(!serialized.contains("disk_size"));

407+ }

408+

409+ #[test]

410+ fn config_deserializes_sizes_from_mb_and_gb() {

411+ let raw = r#"

412+[box]

413+cpu_count = 4

414+ram_mb = 3072

415+disk_gb = 12

416+mounts = ["~/src:~/src:read-write"]

417+

418+[supervisor]

419+auto_shutdown_ms = 15000

420+"#;

421+ let cfg: Config = toml::from_str(raw).expect("config should deserialize");

422+

423+ assert_eq!(cfg.box_cfg.cpu_count, 4);

424+ assert_eq!(cfg.box_cfg.ram_size.as_u64(), ByteSize::mib(3072).as_u64());

425+ assert_eq!(cfg.box_cfg.disk_size.as_u64(), ByteSize::gib(12).as_u64());

426+ assert_eq!(cfg.supervisor.auto_shutdown_ms, 15000);

427+ }

428+

429+ #[test]

430+ fn serialize_rejects_non_integral_mb_or_gb() {

431+ let cfg = Config {

432+ box_cfg: BoxConfig {

433+ cpu_count: 2,

434+ ram_size: ByteSize::b((2 * MI_B) + 1),

435+ disk_size: ByteSize::gib(5),

436+ mounts: default_mounts(),

437+ },

438+ supervisor: SupervisorConfig::default(),

439+ };

440+

441+ let err = toml::to_string(&cfg).expect_err("serialization should reject invalid MB");

442+ assert!(

443+ err.to_string()

444+ .contains("ram_mb must be an integer number of MB")

445+ );

446+

447+ let cfg = Config {

448+ box_cfg: BoxConfig {

449+ cpu_count: 2,

450+ ram_size: ByteSize::mib(2048),

451+ disk_size: ByteSize::b((5 * GI_B) + 1),

452+ mounts: default_mounts(),

453+ },

454+ supervisor: SupervisorConfig::default(),

455+ };

456+

457+ let err = toml::to_string(&cfg).expect_err("serialization should reject invalid GB");

458+ assert!(

459+ err.to_string()

460+ .contains("disk_gb must be an integer number of GB")

461+ );

462+ }

463+

464+ #[test]

465+ fn normalize_path_removes_dot_and_parent_components() {

466+ let normalized = normalize_path(Path::new("/tmp/project/./nested/../config.toml"));

467+ assert_eq!(normalized, PathBuf::from("/tmp/project/config.toml"));

468+ }

469+

470+ #[test]

471+ fn validate_schema_returns_errors_for_missing_required_fields() {

472+ let value: toml::Value = toml::from_str(

473+ r#"

474+[box]

475+cpu_count = 2

476+"#,

477+ )

478+ .expect("toml should parse");

479+

480+ let errors = validate_schema(&value);

481+

482+ assert!(errors.iter().any(|e| e == "missing [supervisor] table"));

483+ assert!(errors.iter().any(|e| e == "missing [box].ram_mb (integer)"));

484+ assert!(

485+ errors

486+ .iter()

487+ .any(|e| e == "missing [box].disk_gb (integer)")

488+ );

489+ assert!(

490+ errors

491+ .iter()

492+ .any(|e| e == "missing [box].mounts (array of strings)")

493+ );

494+ }

495+

496+ #[test]

497+ fn validate_schema_errors_when_supervisor_is_not_table() {

498+ let value: toml::Value = toml::from_str(

499+ r#"

500+supervisor = 123

501+

502+[box]

503+cpu_count = 2

504+ram_mb = 2048

505+disk_gb = 5

506+mounts = []

507+"#,

508+ )

509+ .expect("toml should parse");

510+

511+ let errors = validate_schema(&value);

512+ assert!(errors.iter().any(|e| e == "[supervisor] must be a table"));

513+ }

514+

515+ #[test]

516+ fn ensure_config_file_creates_default_config_if_absent() {

517+ let temp = TempDir::new().expect("temp dir should be created");

518+ let root = fs::canonicalize(temp.path()).expect("temp dir should canonicalize");

519+

520+ let path = ensure_config_file(&root, None).expect("config should be created");

521+ let raw = fs::read_to_string(&path).expect("created config should be readable");

522+ let parsed: Config = toml::from_str(&raw).expect("created config should be valid");

523+

524+ assert_eq!(path, root.join("vibebox.toml"));

525+ assert_eq!(parsed.box_cfg.cpu_count, DEFAULT_CPU_COUNT);

526+ assert_eq!(

527+ parsed.box_cfg.ram_size.as_u64(),

528+ ByteSize::mib(DEFAULT_RAM_MB).as_u64()

529+ );

530+ assert_eq!(

531+ parsed.box_cfg.disk_size.as_u64(),

532+ ByteSize::gib(DEFAULT_DISK_GB).as_u64()

533+ );

534+ }

535+

536+ #[test]

537+ fn load_config_creates_and_loads_default_config() {

538+ let _lock = ENV_MUTEX.lock().expect("env lock should be acquired");

539+ let temp = TempDir::new().expect("temp dir should be created");

540+ let root = fs::canonicalize(temp.path()).expect("temp dir should canonicalize");

541+ let home = root.join("home");

542+ fs::create_dir_all(home.join(".codex")).expect("home .codex should be created");

543+ fs::create_dir_all(home.join(".claude")).expect("home .claude should be created");

544+ let _home_guard = EnvGuard::set("HOME", &home);

545+

546+ let cfg = load_config(&root).expect("load_config should succeed");

547+

548+ assert_eq!(cfg.box_cfg.cpu_count, DEFAULT_CPU_COUNT);

549+ assert_eq!(

550+ cfg.box_cfg.ram_size.as_u64(),

551+ ByteSize::mib(DEFAULT_RAM_MB).as_u64()

552+ );

553+ assert_eq!(

554+ cfg.box_cfg.disk_size.as_u64(),

555+ ByteSize::gib(DEFAULT_DISK_GB).as_u64()

556+ );

557+ assert!(root.join("vibebox.toml").exists());

558+ }

559+

560+ #[test]

561+ fn load_config_with_path_uses_override_path() {

562+ let _lock = ENV_MUTEX.lock().expect("env lock should be acquired");

563+ let temp = TempDir::new().expect("temp dir should be created");

564+ let root = fs::canonicalize(temp.path()).expect("temp dir should canonicalize");

565+ let home = root.join("home");

566+ fs::create_dir_all(home.join(".codex")).expect("home .codex should be created");

567+ fs::create_dir_all(home.join(".claude")).expect("home .claude should be created");

568+ let _home_guard = EnvGuard::set("HOME", &home);

569+ let override_path = root.join("custom.toml");

570+

571+ fs::write(

572+ &override_path,

573+ r#"

574+[box]

575+cpu_count = 6

576+ram_mb = 4096

577+disk_gb = 9

578+mounts = ["~/.codex:~/.codex:read-write", "~/.claude:~/.claude:read-write"]

579+

580+[supervisor]

581+auto_shutdown_ms = 12345

582+"#,

583+ )

584+ .expect("override config should be written");

585+

586+ let cfg = load_config_with_path(&root, Some(Path::new("custom.toml")))

587+ .expect("load_config_with_path should succeed");

588+

589+ assert_eq!(cfg.box_cfg.cpu_count, 6);

590+ assert_eq!(cfg.box_cfg.ram_size.as_u64(), ByteSize::mib(4096).as_u64());

591+ assert_eq!(cfg.box_cfg.disk_size.as_u64(), ByteSize::gib(9).as_u64());

592+ assert_eq!(cfg.supervisor.auto_shutdown_ms, 12345);

593+ assert!(!root.join("vibebox.toml").exists());

594+ }

595+

596+ #[test]

597+ fn resolve_config_path_uses_env_override_when_cli_override_missing() {

598+ let temp = TempDir::new().expect("temp dir should be created");

599+ let root = fs::canonicalize(temp.path()).expect("temp dir should canonicalize");

600+

601+ let resolved = resolve_config_path_inner(&root, None, Some(PathBuf::from("custom.toml")))

602+ .expect("env override path should resolve");

603+

604+ assert_eq!(resolved, root.join("custom.toml"));

605+ }

606+

607+ #[test]

608+ fn resolve_config_path_rejects_env_override_outside_project() {

609+ let temp = TempDir::new().expect("temp dir should be created");

610+ let root = fs::canonicalize(temp.path()).expect("temp dir should canonicalize");

611+

612+ let err = resolve_config_path_inner(&root, None, Some(PathBuf::from("../escape.toml")))

613+ .expect_err("outside-project path should be rejected");

614+

615+ assert!(

616+ err.to_string().contains("config path must be within"),

617+ "expected bounds-check error, got: {err}"

618+ );

619+ }

620+

621+ #[test]

622+ fn validate_config_rejects_invalid_values() {

623+ let cfg = Config {

624+ box_cfg: BoxConfig {

625+ cpu_count: 0,

626+ ram_size: ByteSize::mib(2048),

627+ disk_size: ByteSize::gib(5),

628+ mounts: vec![],

629+ },

630+ supervisor: SupervisorConfig::default(),

631+ };

632+ let err = validate_config(&cfg).expect_err("cpu_count=0 should fail");

633+ assert_eq!(err, "box.cpu_count must be >= 1");

634+

635+ let cfg = Config {

636+ box_cfg: BoxConfig {

637+ cpu_count: 2,

638+ ram_size: ByteSize::mib(2048),

639+ disk_size: ByteSize::gib(5),

640+ mounts: vec!["/definitely/missing:/tmp/missing:read-write".to_string()],

641+ },

642+ supervisor: SupervisorConfig::default(),

643+ };

644+ let err = validate_config(&cfg).expect_err("invalid mount should fail");

645+ assert!(err.starts_with("invalid mount spec"));

646+ }

647+

648+ #[test]

649+ fn resolve_config_path_accepts_symlinked_project_root() {

650+ let temp = TempDir::new().expect("temp dir should be created");

651+ let actual_root = temp.path().join("actual");

652+ let link_root = temp.path().join("linked");

653+ fs::create_dir_all(&actual_root).expect("actual root should exist");

654+ std::os::unix::fs::symlink(&actual_root, &link_root).expect("symlink should be created");

655+

656+ let resolved = resolve_config_path_inner(&link_root, Some(Path::new("vibebox.toml")), None)

657+ .expect("symlinked project root should resolve");

658+

659+ assert_eq!(resolved, link_root.join("vibebox.toml"));

660+ }

661+

662+ #[test]

663+ fn resolve_config_path_rejects_symlink_escape() {

664+ let temp = TempDir::new().expect("temp dir should be created");

665+ let project_root = temp.path().join("project");

666+ let outside_root = temp.path().join("outside");

667+ fs::create_dir_all(&project_root).expect("project root should exist");

668+ fs::create_dir_all(&outside_root).expect("outside root should exist");

669+ std::os::unix::fs::symlink(&outside_root, project_root.join("link"))

670+ .expect("escape symlink should be created");

671+

672+ let err = resolve_config_path_inner(&project_root, Some(Path::new("link/cfg.toml")), None)

673+ .expect_err("symlink escape should be rejected");

674+ assert!(

675+ err.to_string().contains("config path must be within"),

676+ "expected bounds-check error, got: {err}"

677+ );

678+ }

289679}

src/error_report.shnew file+28

@@ -0,0 +1,28 @@

1+#!/usr/bin/env bash

2+set -Eeuo pipefail

3+__vibebox_err_reported=0

4+__vibebox_report_error() {

5+ local rc="$1"

6+ local line="$2"

7+ local msg="${3:-}"

8+ if [ "$__vibebox_err_reported" -eq 0 ]; then

9+ msg="${msg//$'\n'/ }"

10+ msg="${msg//$'\r'/ }"

11+ if [ -n "$msg" ]; then

12+ echo "VIBEBOX_SCRIPT_ERROR:__LABEL__:${line}:${rc} ${msg}"

13+ else

14+ echo "VIBEBOX_SCRIPT_ERROR:__LABEL__:${line}:${rc}"

15+ fi

16+ __vibebox_err_reported=1

17+ fi

18+}

19+vibebox_fail() {

20+ local msg="${1:-script failed}"

21+ local rc="${2:-1}"

22+ __vibebox_report_error "$rc" "${LINENO}" "$msg"

23+ exit "$rc"

24+}

25+trap 'rc="$?"; __vibebox_report_error "$rc" "${LINENO}" "command failed: ${BASH_COMMAND:-unknown}"' ERR

26+trap 'rc="$?"; if [ "$rc" -ne 0 ]; then __vibebox_report_error "$rc" "${LINENO}" "script exited with code ${rc}"; fi' EXIT

27+

28+__SCRIPT_BODY__

src/explain.rs+32−47

@@ -1,31 +1,31 @@

1+use crate::instance::InstanceConfig;

2+use crate::utils::relative_to_home;

3+use crate::{config, instance, session_manager, tui};

4+use anyhow::{Context, Result, bail};

15use std::{

26 env,

3− error::Error,

47 path::{Path, PathBuf},

58};

7−use crate::{config, instance, session_manager, tui};

8−

9−pub fn build_mount_rows(

10− cwd: &Path,

11− config: &config::Config,

12−) -> Result<Vec<tui::MountListRow>, Box<dyn Error + Send + Sync>> {

10+pub fn build_mount_rows(project: &Path, config: &config::Config) -> Result<Vec<tui::MountListRow>> {

1311 let mut rows = Vec::new();

14− rows.extend(default_mounts(cwd)?);

15− let guest_home = resolve_guest_home(cwd)?;

12+ rows.extend(default_mounts(project)?);

13+ let guest_home = resolve_guest_home(project);

1614 for spec in &config.box_cfg.mounts {

17− rows.push(parse_mount_spec(cwd, spec, false, &guest_home)?);

15+ rows.push(parse_mount_spec(project, spec, false, &guest_home)?);

1816 }

1917 Ok(rows)

2018}

2119

22−pub fn build_network_rows(

23− cwd: &Path,

24−) -> Result<Vec<tui::NetworkListRow>, Box<dyn Error + Send + Sync>> {

25− let instance_dir = cwd.join(session_manager::INSTANCE_DIR_NAME);

20+pub fn build_network_rows(project_dir: &Path) -> Result<Vec<tui::NetworkListRow>> {

2621 let mut vm_ip = "-".to_string();

27− if let Ok(Some(ip)) = instance::read_instance_vm_ip(&instance_dir) {

28− vm_ip = ip;

22+ if let Ok(config) = instance::read_instance_config(project_dir) {

23+ match config.vm_ipv4 {

24+ None => {}

25+ Some(ip) => {

26+ vm_ip = ip;

27+ }

28+ }

2929 }

3030 let host_to_vm = if vm_ip == "-" {

3131 "ssh: <pending>:22".to_string()

@@ -41,13 +41,13 @@ pub fn build_network_rows(

4141 Ok(vec![row])

4242}

4343

44−fn default_mounts(cwd: &Path) -> Result<Vec<tui::MountListRow>, Box<dyn Error + Send + Sync>> {

44+fn default_mounts(cwd: &Path) -> Result<Vec<tui::MountListRow>> {

4545 let project_name = cwd

4646 .file_name()

4747 .and_then(|name| name.to_str())

48− .unwrap_or("project");

48+ .with_context(|| "failed to get project name")?;

4949 let project_guest = format!("~/{project_name}");

50− let project_host = display_path(cwd);

50+ let project_host = relative_to_home(cwd);

5151 let mut rows = vec![tui::MountListRow {

5252 host: project_host,

5353 guest: project_guest,

@@ -57,14 +57,14 @@ fn default_mounts(cwd: &Path) -> Result<Vec<tui::MountListRow>, Box<dyn Error +

5757

5858 let home = env::var("HOME")

5959 .map(PathBuf::from)

60− .unwrap_or_else(|_| PathBuf::from("/"));

60+ .with_context(|| "failed to get home directory")?;

6161 let cache_home = env::var("XDG_CACHE_HOME")

6262 .map(PathBuf::from)

6363 .unwrap_or_else(|_| home.join(".cache"));

6464 let cache_dir = cache_home.join(session_manager::GLOBAL_CACHE_DIR_NAME);

6565 let guest_mise_cache = cache_dir.join(".guest-mise-cache");

6666 rows.push(tui::MountListRow {

67− host: display_path(&guest_mise_cache),

67+ host: relative_to_home(&guest_mise_cache),

6868 guest: "/root/.local/share/mise".to_string(),

6969 mode: "read-write".to_string(),

7070 default_mount: "yes".to_string(),

@@ -77,10 +77,10 @@ fn parse_mount_spec(

7777 spec: &str,

7878 default_mount: bool,

7979 guest_home: &str,

80−) -> Result<tui::MountListRow, Box<dyn Error + Send + Sync>> {

80+) -> Result<tui::MountListRow> {

8181 let parts: Vec<&str> = spec.split(':').collect();

8282 if parts.len() < 2 || parts.len() > 3 {

83− return Err(format!("invalid mount spec: {spec}").into());

83+ bail!["invalid mount spec: {spec}"];

8484 }

8585 let host_part = parts[0];

8686 let guest_part = parts[1];

@@ -89,11 +89,10 @@ fn parse_mount_spec(

8989 "read-only" => "read-only",

9090 "read-write" => "read-write",

9191 other => {

92− return Err(format!(

92+ bail![format!(

9393 "invalid mount mode '{}'; expected read-only or read-write",

9494 other

95− )

96− .into());

95+ )];

9796 }

9897 }

9998 } else {

@@ -116,22 +115,22 @@ fn display_host_spec(cwd: &Path, host: &str) -> String {

116115 }

117116 let host_path = PathBuf::from(host);

118117 if host_path.is_absolute() {

119− return display_path(&host_path);

118+ return relative_to_home(&host_path);

120119 }

121120 let candidate = cwd.join(&host_path);

122121 if candidate.is_absolute() {

123− display_path(&candidate)

122+ relative_to_home(&candidate)

124123 } else {

125124 host.to_string()

126125 }

127126}

128127

129−fn resolve_guest_home(cwd: &Path) -> Result<String, Box<dyn Error + Send + Sync>> {

130− let instance_dir = cwd.join(session_manager::INSTANCE_DIR_NAME);

131− if let Ok(Some(user)) = instance::read_instance_ssh_user(&instance_dir) {

132− return Ok(format!("/home/{user}"));

128+fn resolve_guest_home(project_dir: &Path) -> String {

129+ let config = instance::read_instance_config(project_dir);

130+ match config {

131+ Ok(config) => format!("/home/{}", config.ssh_user),

132+ Err(_) => format!("/home/{}", InstanceConfig::default().ssh_user),

133133 }

134− Ok(format!("/home/{}", instance::DEFAULT_SSH_USER))

135134}

136135

137136fn resolve_guest_display(guest: &str, guest_home: &str) -> String {

@@ -155,17 +154,3 @@ fn resolve_guest_display(guest: &str, guest_home: &str) -> String {

155154 format!("/root/{guest}")

156155 }

157156}

158−

159−fn display_path(path: &Path) -> String {

160− let Ok(home) = env::var("HOME") else {

161− return path.display().to_string();

162− };

163− let home_path = PathBuf::from(home);

164− if let Ok(stripped) = path.strip_prefix(&home_path) {

165− if stripped.components().next().is_none() {

166− return "~".to_string();

167− }

168− return format!("~/{}", stripped.display());

169− }

170− path.display().to_string()

171−}

src/instance.rs+289−154

@@ -1,82 +1,140 @@

1+use anyhow::{Context, Result, bail};

2+use serde::{Deserialize, Serialize};

3+use std::os::unix::fs::FileTypeExt;

14use std::{

25 env, fs,

3− io::{self},

6+ io::{self, IsTerminal, Read},

47 net::{SocketAddr, TcpStream},

58 os::unix::{fs::PermissionsExt, net::UnixStream},

69 path::{Path, PathBuf},

7− process::{Command, Stdio},

8− sync::{Arc, Mutex},

10+ process::{Child, Command, Stdio},

11+ sync::{

12+ Arc, Mutex,

13+ atomic::{AtomicBool, Ordering},

14+ mpsc,

15+ },

916 thread,

1017 time::{Duration, Instant},

1118};

12−

13−use serde::{Deserialize, Serialize};

1419use time::{OffsetDateTime, format_description::well_known::Rfc3339};

1520use uuid::Uuid;

1621

1722use crate::{

1823 commands,

19− session_manager::{INSTANCE_DIR_NAME, INSTANCE_FILENAME},

24+ session_manager::INSTANCE_DIR_NAME,

25+ session_manager::{VM_MANAGER_PID_NAME, VM_MANAGER_SOCKET_NAME},

2026 vm::{self, LoginAction},

2127};

2228

29+pub const STATUS_VM_ERROR_PREFIX: &str = "error:";

30+

2331const SSH_KEY_NAME: &str = "ssh_key";

24−#[cfg_attr(feature = "mock-vm", allow(dead_code))]

25−pub(crate) const VM_ROOT_LOG_NAME: &str = "vm_root.log";

26−pub(crate) const STATUS_FILE_NAME: &str = "status.txt";

27−pub(crate) const DEFAULT_SSH_USER: &str = "vibecoder";

28−const SSH_CONNECT_RETRIES: usize = 30;

32+const INSTANCE_FILENAME: &str = "instance.toml";

33+const DEFAULT_SSH_USER: &str = "vibecoder";

34+const SSH_CONNECT_RETRIES: usize = 10;

2935const SSH_CONNECT_DELAY_MS: u64 = 500;

3036const SSH_SETUP_SCRIPT: &str = include_str!("ssh.sh");

37+const STATUS_PREFIX: &str = "status:";

38+

39+#[derive(Debug, Clone, Copy, PartialEq, Eq)]

40+pub enum VmLiveness {

41+ RunningWithSocket { pid: u32 },

42+ RunningWithoutSocket { pid: u32 },

43+ NotRunningOrMissing,

44+}

45+

46+pub fn vm_liveness(project_root: &Path) -> Result<VmLiveness> {

47+ let instance_dir = ensure_instance_dir(project_root)?;

48+ let pid_path = instance_dir.join(VM_MANAGER_PID_NAME);

49+ let socket_path = instance_dir.join(VM_MANAGER_SOCKET_NAME);

50+ fn pid_is_alive(pid: u32) -> bool {

51+ let pid = pid as libc::pid_t;

52+ let result = unsafe { libc::kill(pid, 0) };

53+ if result == 0 {

54+ return true;

55+ }

56+ match io::Error::last_os_error().raw_os_error() {

57+ Some(code) if code == libc::EPERM => true,

58+ Some(code) if code == libc::ESRCH => false,

59+ _ => false,

60+ }

61+ }

62+ let Ok(content) = fs::read_to_string(pid_path) else {

63+ return Ok(VmLiveness::NotRunningOrMissing);

64+ };

65+ let Ok(pid) = content.trim().parse::<u32>() else {

66+ return Ok(VmLiveness::NotRunningOrMissing);

67+ };

68+ if !pid_is_alive(pid) {

69+ return Ok(VmLiveness::NotRunningOrMissing);

70+ }

71+ let has_socket = fs::metadata(socket_path)

72+ .map(|meta| meta.file_type().is_socket())

73+ .unwrap_or(false);

74+ if has_socket {

75+ Ok(VmLiveness::RunningWithSocket { pid })

76+ } else {

77+ Ok(VmLiveness::RunningWithoutSocket { pid })

78+ }

79+}

80+

81+#[derive(Debug, thiserror::Error)]

82+pub enum InstanceError {

83+ #[error("unexpected disconnection from vm manager")]

84+ UnexpectedDisconnection,

85+ #[error("{0}")]

86+ VMError(String),

87+}

88+

89+fn default_ssh_user() -> String {

90+ DEFAULT_SSH_USER.to_string()

91+}

3192

3293#[derive(Debug, Clone, Serialize, Deserialize)]

33−pub(crate) struct InstanceConfig {

94+pub struct InstanceConfig {

3495 #[serde(default)]

35− id: String,

96+ pub id: String,

3697 #[serde(default = "default_ssh_user")]

37− ssh_user: String,

98+ pub ssh_user: String,

3899 #[serde(default)]

39100 sudo_password: String,

40101 #[serde(default)]

41− last_active: Option<String>,

102+ pub last_active: Option<String>,

42103 #[serde(default)]

43− pub(crate) vm_ipv4: Option<String>,

104+ pub vm_ipv4: Option<String>,

44105}

45106

46−impl InstanceConfig {

47− pub(crate) fn ssh_user_display(&self) -> String {

48− if self.ssh_user.trim().is_empty() {

49− DEFAULT_SSH_USER.to_string()

50− } else {

51− self.ssh_user.clone()

107+impl Default for InstanceConfig {

108+ fn default() -> Self {

109+ Self {

110+ id: Uuid::now_v7().to_string(),

111+ ssh_user: DEFAULT_SSH_USER.to_string(),

112+ sudo_password: Uuid::now_v7().simple().to_string(),

113+ last_active: None,

114+ vm_ipv4: None,

52115 }

53116 }

54117}

55118

56−fn default_ssh_user() -> String {

57− DEFAULT_SSH_USER.to_string()

58−}

59−

60−pub fn run_with_ssh(manager_conn: UnixStream) -> Result<(), Box<dyn std::error::Error>> {

119+pub fn run_with_ssh(manager_conn: UnixStream) -> Result<()> {

61120 let project_root = env::current_dir()?;

62121 tracing::info!(root = %project_root.display(), "starting ssh session");

63122 let instance_dir = ensure_instance_dir(&project_root)?;

64123 tracing::debug!(instance_dir = %instance_dir.display(), "instance dir ready");

65124 let (ssh_key, _ssh_pub) = ensure_ssh_keypair(&instance_dir)?;

66125

67− let config = load_or_create_instance_config(&instance_dir)?;

126+ let config = load_or_create_instance_config(&project_root)?;

68127 let ssh_user = config.ssh_user.clone();

69128 tracing::debug!(ssh_user = %ssh_user, "loaded instance config");

70129

71− let _manager_conn = manager_conn;

72− wait_for_vm_ipv4(&instance_dir, Duration::from_secs(480))?;

130+ wait_for_vm_ipv4(&project_root, Duration::from_secs(480), &manager_conn)?;

73131

74− let ip = load_or_create_instance_config(&instance_dir)?

132+ let ip = load_or_create_instance_config(&project_root)?

75133 .vm_ipv4

76− .ok_or("VM IPv4 not available")?;

134+ .with_context(|| "failed to load instance IP address")?;

77135 tracing::info!(ip = %ip, "vm ipv4 ready");

78136

79− run_ssh_session(ssh_key, ssh_user, ip)

137+ run_ssh_session(ssh_key, ssh_user, ip, manager_conn, project_root)

80138}

81139

82140pub fn ensure_instance_dir(project_root: &Path) -> Result<PathBuf, io::Error> {

@@ -85,9 +143,7 @@ pub fn ensure_instance_dir(project_root: &Path) -> Result<PathBuf, io::Error> {

85143 Ok(instance_dir)

86144}

87145

88−pub(crate) fn ensure_ssh_keypair(

89− instance_dir: &Path,

90−) -> Result<(PathBuf, PathBuf), Box<dyn std::error::Error>> {

146+pub fn ensure_ssh_keypair(instance_dir: &Path) -> Result<(PathBuf, PathBuf)> {

91147 let private_key = instance_dir.join(SSH_KEY_NAME);

92148 let public_key = instance_dir.join(format!("{SSH_KEY_NAME}.pub"));

93149

@@ -109,7 +165,9 @@ pub(crate) fn ensure_ssh_keypair(

109165 "-N",

110166 "",

111167 "-f",

112− private_key.to_str().ok_or("ssh key path not utf-8")?,

168+ private_key

169+ .to_str()

170+ .with_context(|| "ssh key path not utf-8")?,

113171 "-C",

114172 "vibebox",

115173 ])

@@ -119,7 +177,7 @@ pub(crate) fn ensure_ssh_keypair(

119177 .status()?;

120178

121179 if !status.success() {

122− return Err("ssh-keygen failed".into());

180+ bail!("ssh-keygen failed");

123181 }

124182

125183 fs::set_permissions(&private_key, fs::Permissions::from_mode(0o600))?;

@@ -128,98 +186,66 @@ pub(crate) fn ensure_ssh_keypair(

128186 Ok((private_key, public_key))

129187}

130188

131−pub(crate) fn load_or_create_instance_config(

132− instance_dir: &Path,

133−) -> Result<InstanceConfig, Box<dyn std::error::Error>> {

134− let config_path = instance_dir.join(INSTANCE_FILENAME);

135− let mut config = if config_path.exists() {

136− let raw = fs::read_to_string(&config_path)?;

137− toml::from_str::<InstanceConfig>(&raw)?

138− } else {

139− InstanceConfig {

140− id: String::new(),

141− ssh_user: default_ssh_user(),

142− sudo_password: String::new(),

143− last_active: None,

144− vm_ipv4: None,

145− }

146− };

189+pub fn load_or_create_instance_config(project_dir: &Path) -> Result<InstanceConfig> {

190+ let mut exist = true;

191+ let mut config = read_instance_config(project_dir).unwrap_or_else(|_| {

192+ exist = false;

193+ InstanceConfig::default()

194+ });

147195

148196 let mut changed = false;

149197 if config.ssh_user.trim().is_empty() {

150− config.ssh_user = default_ssh_user();

198+ config.ssh_user = InstanceConfig::default().ssh_user;

151199 changed = true;

152200 }

153201

154202 if config.id.trim().is_empty() {

155− config.id = Uuid::now_v7().to_string();

203+ config.id = InstanceConfig::default().id;

156204 changed = true;

157205 }

158206

159207 if config.sudo_password.trim().is_empty() {

160− config.sudo_password = generate_password();

208+ config.sudo_password = InstanceConfig::default().sudo_password;

161209 changed = true;

162210 }

163211

164− if !config_path.exists() || changed {

165− write_instance_config(&config_path, &config)?;

212+ if !exist || changed {

213+ write_instance_config(project_dir, &config)?;

166214 }

167215

168216 Ok(config)

169217}

170218

171−fn read_instance_config(

172− instance_dir: &Path,

173−) -> Result<Option<InstanceConfig>, Box<dyn std::error::Error>> {

174− let config_path = instance_dir.join(INSTANCE_FILENAME);

219+pub fn read_instance_config(project_dir: &Path) -> Result<InstanceConfig> {

220+ // todo maybe verify schema?

221+ let config_path = project_dir.join(INSTANCE_DIR_NAME).join(INSTANCE_FILENAME);

175222 if !config_path.exists() {

176− return Ok(None);

223+ bail!("instance config file does not exist");

177224 }

178225 let raw = fs::read_to_string(&config_path)?;

179226 let config = toml::from_str::<InstanceConfig>(&raw)?;

180− Ok(Some(config))

181−}

182−

183−pub fn read_instance_vm_ip(

184− instance_dir: &Path,

185−) -> Result<Option<String>, Box<dyn std::error::Error>> {

186− let config = read_instance_config(instance_dir)?;

187− Ok(config.and_then(|cfg| cfg.vm_ipv4))

188−}

189−

190−pub fn read_instance_ssh_user(

191− instance_dir: &Path,

192−) -> Result<Option<String>, Box<dyn std::error::Error>> {

193− let config = read_instance_config(instance_dir)?;

194− Ok(config

195− .map(|cfg| cfg.ssh_user)

196− .filter(|user| !user.trim().is_empty()))

227+ Ok(config)

197228}

198229

199−pub fn touch_last_active(instance_dir: &Path) -> Result<(), Box<dyn std::error::Error>> {

200− let mut config = load_or_create_instance_config(instance_dir)?;

230+pub fn touch_last_active(project_dir: &Path) -> Result<()> {

231+ let mut config = load_or_create_instance_config(project_dir)?;

201232 let now = OffsetDateTime::now_utc().format(&Rfc3339)?;

202233 config.last_active = Some(now);

203− write_instance_config(&instance_dir.join(INSTANCE_FILENAME), &config)?;

234+ write_instance_config(project_dir, &config)?;

204235 Ok(())

205236}

206237

207−pub(crate) fn write_instance_config(

208− path: &Path,

209− config: &InstanceConfig,

210−) -> Result<(), Box<dyn std::error::Error>> {

238+pub fn write_instance_config(project_dir: &Path, config: &InstanceConfig) -> Result<()> {

239+ let path = project_dir.join(INSTANCE_DIR_NAME).join(INSTANCE_FILENAME);

211240 let data = toml::to_string_pretty(config)?;

212− fs::write(path, data)?;

213− fs::set_permissions(path, fs::Permissions::from_mode(0o600))?;

241+ fs::create_dir_all(project_dir.join(INSTANCE_DIR_NAME))?;

242+ fs::write(&path, data)?;

243+ fs::set_permissions(&path, fs::Permissions::from_mode(0o600))?;

214244 Ok(())

215245}

216246

217−fn generate_password() -> String {

218− Uuid::now_v7().simple().to_string()

219−}

220−

221247#[cfg_attr(feature = "mock-vm", allow(dead_code))]

222−pub(crate) fn extract_ipv4(line: &str) -> Option<String> {

248+pub fn extract_ipv4(line: &str) -> Option<String> {

223249 let mut current = String::new();

224250 let mut best: Option<String> = None;

225251

@@ -238,51 +264,68 @@ pub(crate) fn extract_ipv4(line: &str) -> Option<String> {

238264 best

239265}

240266

267+fn handle_manager_line(line: &str, last_status: &mut Option<String>) -> Result<()> {

268+ if let Some(status) = line.strip_prefix(STATUS_PREFIX) {

269+ let status = status.trim();

270+ if let Some(message) = status.strip_prefix(STATUS_VM_ERROR_PREFIX) {

271+ let message = message.trim();

272+ if message.is_empty() {

273+ bail!("vm manager reported startup failure");

274+ }

275+ return Err(InstanceError::VMError(message.to_string()).into());

276+ }

277+ if !status.is_empty() && last_status.as_deref() != Some(status) {

278+ tracing::info!("[background]: {}", status);

279+ *last_status = Some(status.to_string());

280+ }

281+ }

282+ Ok(())

283+}

284+

241285fn wait_for_vm_ipv4(

242− instance_dir: &Path,

286+ project_dir: &Path,

243287 timeout: Duration,

244−) -> Result<(), Box<dyn std::error::Error>> {

288+ manager_conn: &UnixStream,

289+) -> Result<()> {

245290 let start = Instant::now();

246291 let mut next_log_at = start + Duration::from_secs(10);

247− let mut next_status_check = start;

292+ let mut stream = manager_conn.try_clone()?;

293+ let _ = stream.set_read_timeout(Some(Duration::from_millis(250)));

294+ let mut read_buf = [0u8; 1024];

295+ let mut pending = String::new();

248296 tracing::info!("waiting for vm ipv4");

249− let status_path = instance_dir.join(STATUS_FILE_NAME);

250297 let mut last_status: Option<String> = None;

251− let mut status_missing = true;

252298 let mut once_hint = false;

253299 loop {

254− let config = load_or_create_instance_config(instance_dir)?;

300+ match stream.read(&mut read_buf) {

301+ Ok(0) => {

302+ bail!("vm manager disconnected before VM became ready");

303+ }

304+ Ok(n) => {

305+ pending.push_str(&String::from_utf8_lossy(&read_buf[..n]));

306+ while let Some(pos) = pending.find('\n') {

307+ let line = pending[..pos].trim().to_string();

308+ pending.drain(..=pos);

309+ handle_manager_line(&line, &mut last_status)?;

310+ }

311+ }

312+ Err(err) if err.kind() == io::ErrorKind::WouldBlock => {}

313+ Err(err) if err.kind() == io::ErrorKind::TimedOut => {}

314+ Err(err) if err.kind() == io::ErrorKind::Interrupted => {}

315+ Err(err) => {

316+ tracing::warn!(error = %err, "failed to read vm manager status stream");

317+ }

318+ }

319+

320+ let config = load_or_create_instance_config(project_dir)?;

255321 if config.vm_ipv4.is_some() {

256− let _ = fs::remove_file(&status_path);

257322 return Ok(());

258323 }

259324 if start.elapsed() > timeout {

260− let _ = fs::remove_file(&status_path);

261− return Err("Timed out waiting for VM IPv4".into());

325+ bail!("timed out waiting for VM IPv4");

262326 }

327+

263328 let now = Instant::now();

264− if now >= next_status_check {

265− match fs::read_to_string(&status_path) {

266− Ok(status) => {

267− status_missing = false;

268− let status = status.trim().to_string();

269− if status.starts_with("error:") {

270− let _ = fs::remove_file(&status_path);

271− let message = status.trim_start_matches("error:").trim().to_string();

272− return Err(message.into());

273− }

274− if !status.is_empty() && last_status.as_deref() != Some(status.as_str()) {

275− tracing::info!("[background]: {}", status);

276− last_status = Some(status);

277− next_log_at = now + Duration::from_secs(20);

278− }

279− }

280− Err(_) => {

281− status_missing = true;

282− }

283− }

284− next_status_check = now + Duration::from_millis(500);

285− }

286329 if now >= next_log_at {

287330 let waited = start.elapsed();

288331 if waited.as_secs() > 15 && !once_hint {

@@ -291,12 +334,9 @@ fn wait_for_vm_ipv4(

291334 );

292335 once_hint = true;

293336 }

294− if status_missing {

295− tracing::info!("still waiting for vm ipv4, {}s elapsed", waited.as_secs(),);

296− }

337+ tracing::info!("still waiting for vm ipv4, {}s elapsed", waited.as_secs(),);

297338 next_log_at += Duration::from_secs(20);

298339 }

299− thread::sleep(Duration::from_millis(200));

300340 }

301341}

302342

@@ -304,9 +344,14 @@ fn run_ssh_session(

304344 ssh_key: PathBuf,

305345 ssh_user: String,

306346 ip: String,

307−) -> Result<(), Box<dyn std::error::Error>> {

347+ manager_conn: UnixStream,

348+ project_root: PathBuf,

349+) -> Result<()> {

308350 let mut attempts = 0usize;

309351 loop {

352+ if matches!(vm_liveness(&project_root)?, VmLiveness::NotRunningOrMissing) {

353+ return Err(InstanceError::UnexpectedDisconnection.into());

354+ }

310355 attempts += 1;

311356 if !ssh_port_open(&ip) {

312357 tracing::debug!(attempts, "ssh port doesn't open yet");

@@ -318,9 +363,7 @@ fn run_ssh_session(

318363 SSH_CONNECT_RETRIES

319364 );

320365 if attempts >= SSH_CONNECT_RETRIES {

321− return Err(

322− format!("ssh port not ready after {SSH_CONNECT_RETRIES} attempts").into(),

323− );

366+ bail!("ssh port not ready after {SSH_CONNECT_RETRIES} attempts");

324367 }

325368 thread::sleep(Duration::from_millis(SSH_CONNECT_DELAY_MS));

326369 continue;

@@ -334,10 +377,10 @@ fn run_ssh_session(

334377 attempts,

335378 SSH_CONNECT_RETRIES

336379 );

337− let status = Command::new("ssh")

380+ let child = Command::new("ssh")

338381 .args([

339382 "-i",

340− ssh_key.to_str().unwrap_or(".vibebox/ssh_key"),

383+ ssh_key.to_str().with_context(|| "invalid path")?,

341384 "-o",

342385 "IdentitiesOnly=yes",

343386 "-o",

@@ -362,27 +405,67 @@ fn run_ssh_session(

362405 .stdin(Stdio::inherit())

363406 .stdout(Stdio::inherit())

364407 .stderr(Stdio::inherit())

365− .status();

408+ .spawn();

409+

410+ match child {

411+ Ok(mut child) => {

412+ let done = Arc::new(AtomicBool::new(false));

413+ let done_for_monitor = done.clone();

414+ let (disconnect_tx, disconnect_rx) = mpsc::channel::<()>();

415+ let mut manager_stream = manager_conn.try_clone()?;

416+ let _ = manager_stream.set_read_timeout(Some(Duration::from_millis(250)));

417+ thread::spawn(move || {

418+ let mut buf = [0u8; 1];

419+ while !done_for_monitor.load(Ordering::Relaxed) {

420+ match manager_stream.read(&mut buf) {

421+ Ok(0) => {

422+ let _ = disconnect_tx.send(());

423+ return;

424+ }

425+ Ok(_) => {}

426+ Err(err) if err.kind() == io::ErrorKind::WouldBlock => {}

427+ Err(err) if err.kind() == io::ErrorKind::TimedOut => {}

428+ Err(err) if err.kind() == io::ErrorKind::Interrupted => {}

429+ Err(_) => {

430+ let _ = disconnect_tx.send(());

431+ return;

432+ }

433+ }

434+ }

435+ });

436+

437+ let status = loop {

438+ if disconnect_rx.try_recv().is_ok() {

439+ done.store(true, Ordering::Relaxed);

440+ terminate_ssh_child(&mut child);

441+ restore_terminal_after_disconnect();

442+ return Err(InstanceError::UnexpectedDisconnection.into());

443+ }

444+ if let Some(status) = child.try_wait()? {

445+ done.store(true, Ordering::Relaxed);

446+ break status;

447+ }

448+ thread::sleep(Duration::from_millis(100));

449+ };

366450

367− match status {

368− Ok(status) if status.success() => {

369− tracing::info!(status = %status, "ssh exited");

370− break;

371− }

372− Ok(status) if status.code() == Some(255) => {

373− tracing::warn!(status = %status, "ssh connection failed");

374− if attempts >= SSH_CONNECT_RETRIES {

375− return Err(format!("ssh failed after {SSH_CONNECT_RETRIES} attempts").into());

451+ if status.success() {

452+ tracing::info!(status = %status, "ssh exited");

453+ break;

454+ }

455+ if status.code() == Some(255) {

456+ tracing::warn!(status = %status, "ssh connection failed");

457+ if attempts >= SSH_CONNECT_RETRIES {

458+ bail!("ssh failed after {SSH_CONNECT_RETRIES} attempts");

459+ }

460+ thread::sleep(Duration::from_millis(500));

461+ continue;

376462 }

377− thread::sleep(Duration::from_millis(500));

378− }

379− Ok(status) => {

380463 tracing::info!(status = %status, "ssh exited");

381464 break;

382465 }

383466 Err(err) => {

384467 tracing::error!(error = %err, "failed to start ssh");

385− return Err(format!("failed to start ssh: {err}").into());

468+ bail!("failed to start ssh: {err}");

386469 }

387470 }

388471 }

@@ -390,6 +473,30 @@ fn run_ssh_session(

390473 Ok(())

391474}

392475

476+fn terminate_ssh_child(child: &mut Child) {

477+ let pid = child.id() as i32;

478+ unsafe {

479+ libc::kill(pid, libc::SIGTERM);

480+ }

481+ let deadline = Instant::now() + Duration::from_millis(700);

482+ while Instant::now() < deadline {

483+ match child.try_wait() {

484+ Ok(Some(_)) => return,

485+ Ok(None) => thread::sleep(Duration::from_millis(50)),

486+ Err(_) => break,

487+ }

488+ }

489+ let _ = child.kill();

490+ let _ = child.wait();

491+}

492+

493+fn restore_terminal_after_disconnect() {

494+ if io::stdin().is_terminal() {

495+ let _ = Command::new("stty").arg("sane").status();

496+ }

497+ eprintln!();

498+}

499+

393500#[cfg_attr(feature = "mock-vm", allow(dead_code))]

394501fn is_ipv4_candidate(candidate: &str) -> bool {

395502 let parts: Vec<&str> = candidate.split('.').collect();

@@ -412,10 +519,10 @@ fn ssh_port_open(ip: &str) -> bool {

412519 Ok(addr) => addr,

413520 Err(_) => return false,

414521 };

415− TcpStream::connect_timeout(&addr, std::time::Duration::from_millis(500)).is_ok()

522+ TcpStream::connect_timeout(&addr, Duration::from_millis(500)).is_ok()

416523}

417524

418−pub(crate) fn build_ssh_login_actions(

525+pub fn build_ssh_login_actions(

419526 config: &Arc<Mutex<InstanceConfig>>,

420527 project_name: &str,

421528 project_guest_dir: &str,

@@ -430,7 +537,7 @@ pub(crate) fn build_ssh_login_actions(

430537

431538 let key_path = format!("{guest_dir}/{key_name}.pub");

432539

433− let setup_script = SSH_SETUP_SCRIPT

540+ let ssh_script = SSH_SETUP_SCRIPT

434541 .replace("__SSH_USER__", &ssh_user)

435542 .replace("__SUDO_PASSWORD__", &sudo_password)

436543 .replace("__PROJECT_NAME__", project_name)

@@ -438,8 +545,36 @@ pub(crate) fn build_ssh_login_actions(

438545 .replace("__KEY_PATH__", &key_path)

439546 .replace("__VIBEBOX_SHELL_SCRIPT__", &commands::render_shell_script())

440547 .replace("__VIBEBOX_HOME_LINKS__", home_links_script);

441− let setup = vm::script_command_from_content("ssh_setup", &setup_script)

548+ let setup = vm::script_command_from_content("ssh.sh", &ssh_script)

442549 .expect("ssh setup script contained invalid marker");

443550

444551 vec![LoginAction::Send(setup)]

445552}

553+

554+#[cfg(test)]

555+mod tests {

556+ use super::*;

557+

558+ #[test]

559+ fn handle_manager_line_updates_status() {

560+ let mut last_status = None;

561+ handle_manager_line("status: preparing VM image...", &mut last_status)

562+ .expect("status should be accepted");

563+ assert_eq!(last_status.as_deref(), Some("preparing VM image..."));

564+ }

565+

566+ #[test]

567+ fn handle_manager_line_ignores_non_status_lines() {

568+ let mut last_status = None;

569+ handle_manager_line("pid=123", &mut last_status).expect("non-status lines are ignored");

570+ assert!(last_status.is_none());

571+ }

572+

573+ #[test]

574+ fn handle_manager_line_surfaces_error_status() {

575+ let mut last_status = None;

576+ let err = handle_manager_line("status: error: vm failed to boot", &mut last_status)

577+ .expect_err("error status should fail");

578+ assert_eq!(err.to_string(), "vm failed to boot");

579+ }

580+}

src/lib.rs+1

@@ -8,3 +8,4 @@ pub mod vm_manager;

99pub use session_manager::{SessionError, SessionManager, SessionRecord};

1010pub mod config;

11+pub mod utils;

src/provision.sh+7−7

@@ -1,12 +1,12 @@

11#!/bin/bash

22set -eEux

4−trap 'echo "[vibebox][error] provisioning failed"; echo "VIBEBOX_PROVISION_FAILED"; systemctl poweroff || true; exit 1' ERR

4+trap 'rc=$?; echo "[vibebox][error] provisioning failed at: ${BASH_COMMAND} (exit ${rc})"; printf "%s%s\n" VIBEBOX_PROVISION_ FAILED; systemctl poweroff || true; exit 1' ERR

66# Wait for network + DNS before apt-get to avoid early boot flakiness.

77wait_for_network() {

88 echo "[vibebox] waiting for network/DNS readiness"

9− local deadline=$((SECONDS + 60))

9+ local deadline=$((SECONDS + 180))

1010 while [ "$SECONDS" -lt "$deadline" ]; do

1111 local has_route=0

1212 if ip -4 route show default >/dev/null 2>&1; then

@@ -21,7 +21,7 @@ wait_for_network() {

2121 fi

2222 sleep 1

2323 done

24− echo "[vibebox][warn] network/DNS still not ready after 60s; continuing" >&2

24+ echo "[vibebox][warn] network/DNS still not ready after 180s; continuing" >&2

2525 echo "[vibebox][warn] /etc/resolv.conf:" >&2

2626 cat /etc/resolv.conf >&2 || true

2727 ip -br addr >&2 || true

@@ -44,9 +44,9 @@ apt_update_with_retries() {

4444}

4545

4646# Don't wait too long for slow mirrors.

47−echo 'Acquire::http::Timeout "2";' | tee /etc/apt/apt.conf.d/99timeout

48−echo 'Acquire::https::Timeout "2";' | tee -a /etc/apt/apt.conf.d/99timeout

49−echo 'Acquire::Retries "2";' | tee -a /etc/apt/apt.conf.d/99timeout

47+echo 'Acquire::http::Timeout "10";' | tee /etc/apt/apt.conf.d/99timeout

48+echo 'Acquire::https::Timeout "10";' | tee -a /etc/apt/apt.conf.d/99timeout

49+echo 'Acquire::Retries "5";' | tee -a /etc/apt/apt.conf.d/99timeout

5050

5151wait_for_network

5252apt_update_with_retries

@@ -98,5 +98,5 @@ sleep 100 # sleep here so that we don't see the login screen flash up before the

9898EOF

9999

100100# Done provisioning, power off the VM

101−echo "VIBEBOX_PROVISION_OK"

101+printf "%s%s\n" VIBEBOX_PROVISION_ OK

102102systemctl poweroff

src/session_manager.rs+56−93

@@ -1,19 +1,18 @@

1+use anyhow::Result;

12use std::{

23 env, fs,

34 io::{self, Write},

4− os::unix::fs::FileTypeExt,

55 path::{Path, PathBuf},

66};

8+use crate::config::config_path;

9+use crate::instance::{VmLiveness, read_instance_config, vm_liveness};

810use serde::{Deserialize, Serialize};

911

10−use crate::config::CONFIG_FILENAME;

11−

1212pub const INSTANCE_DIR_NAME: &str = ".vibebox";

1313pub const GLOBAL_CACHE_DIR_NAME: &str = "vibebox";

1414pub const GLOBAL_DIR_NAME: &str = ".vibebox";

15−pub const INSTANCE_FILENAME: &str = "instance.toml";

16−pub const SESSION_TOML_SUFFIX: &str = ".toml";

15+const SESSION_TOML_SUFFIX: &str = ".toml";

1716pub const VM_MANAGER_SOCKET_NAME: &str = "vm.sock";

1817pub const VM_MANAGER_PID_NAME: &str = "vm.pid";

1918const SESSIONS_DIR_NAME: &str = "sessions";

@@ -32,14 +31,6 @@ struct SessionEntry {

3231 pub id: String,

3332}

3433

35−#[derive(Debug, Default, Deserialize)]

36−struct InstanceMetadata {

37− #[serde(default)]

38− id: Option<String>,

39− #[serde(default)]

40− last_active: Option<String>,

41−}

42−

4334#[derive(Debug)]

4435pub struct SessionManager {

4536 sessions_dir: PathBuf,

@@ -61,7 +52,7 @@ pub enum SessionError {

6152 #[error("Session directory does not exist: {0}")]

6253 MissingDirectory(PathBuf),

6354 #[error(transparent)]

64− Io(#[from] std::io::Error),

55+ Io(#[from] io::Error),

6556 #[error(transparent)]

6657 TomlDe(#[from] toml::de::Error),

6758 #[error(transparent)]

@@ -94,8 +85,8 @@ impl SessionManager {

9485 let mut added = false;

9586

9687 if has_config {

97− let meta = read_instance_metadata(&directory)?;

98− if let Some(id) = meta.id {

88+ let id = read_instance_config(&directory).map_or(None, |config| Some(config.id));

89+ if let Some(id) = id {

9990 let record = SessionEntry {

10091 directory: directory.clone(),

10192 id: id.clone(),

@@ -110,7 +101,6 @@ impl SessionManager {

110101 } else {

111102 tracing::warn!(

112103 directory = %directory.display(),

113− file = INSTANCE_FILENAME,

114104 "missing session id in instance file"

115105 );

116106 }

@@ -148,12 +138,13 @@ impl SessionManager {

148138 }

149139 let mut records = Vec::with_capacity(sessions.len());

150140 for session in sessions {

151− let meta = read_instance_metadata(&session.directory)?;

141+ let last_active =

142+ read_instance_config(&session.directory).map_or(None, |option| option.last_active);

152143 let active = is_session_active(&session.directory);

153144 records.push(SessionRecord {

154145 directory: session.directory,

155146 id: session.id,

156− last_active: meta.last_active,

147+ last_active,

157148 active,

158149 });

159150 }

@@ -271,43 +262,22 @@ fn is_vibebox_dir(directory: &Path) -> bool {

271262 if !directory.is_absolute() {

272263 return false;

273264 }

274− directory.join(CONFIG_FILENAME).is_file()

265+ config_path(directory).is_file()

275266}

276267

277268fn is_session_active(directory: &Path) -> bool {

278269 let instance_dir = directory.join(INSTANCE_DIR_NAME);

279270 let pid_path = instance_dir.join(VM_MANAGER_PID_NAME);

280− let socket_path = instance_dir.join(VM_MANAGER_SOCKET_NAME);

281−

282− let pid = read_pid(&pid_path);

283− let is_alive = pid.map(pid_is_alive).unwrap_or(false);

284− if !is_alive {

285− let _ = fs::remove_file(&pid_path);

286− return false;

287− }

288−

289− if let Ok(metadata) = fs::metadata(&socket_path) {

290− return metadata.file_type().is_socket();

291− }

292−

293− true

294−}

295−

296−fn read_pid(path: &Path) -> Option<u32> {

297− let content = fs::read_to_string(path).ok()?;

298− content.trim().parse::<u32>().ok()

299−}

300−

301−fn pid_is_alive(pid: u32) -> bool {

302− let pid = pid as libc::pid_t;

303− let result = unsafe { libc::kill(pid, 0) };

304− if result == 0 {

305− return true;

306− }

307− match std::io::Error::last_os_error().raw_os_error() {

308− Some(code) if code == libc::EPERM => true,

309− Some(code) if code == libc::ESRCH => false,

310− _ => false,

271+ match vm_liveness(directory) {

272+ Ok(liveness) => match liveness {

273+ VmLiveness::RunningWithSocket { .. } => true,

274+ VmLiveness::RunningWithoutSocket { .. } => true,

275+ VmLiveness::NotRunningOrMissing => {

276+ let _ = fs::remove_file(&pid_path);

277+ false

278+ }

279+ },

280+ Err(_) => false,

311281 }

312282}

313283

@@ -315,31 +285,11 @@ fn read_session_file(path: &Path) -> Result<SessionEntry, SessionError> {

315285 let raw = fs::read_to_string(path)?;

316286 let record: SessionEntry = toml::from_str(&raw)?;

317287 if record.id.trim().is_empty() {

318− return Err(std::io::Error::new(io::ErrorKind::InvalidData, "session id missing").into());

288+ return Err(io::Error::new(io::ErrorKind::InvalidData, "session id missing").into());

319289 }

320290 Ok(record)

321291}

322292

323−fn read_instance_metadata(directory: &Path) -> Result<InstanceMetadata, SessionError> {

324− let instance_path = directory.join(INSTANCE_DIR_NAME).join(INSTANCE_FILENAME);

325− if !instance_path.exists() {

326− return Ok(InstanceMetadata::default());

327− }

328− let raw = fs::read_to_string(&instance_path)?;

329− let mut meta: InstanceMetadata = toml::from_str(&raw)?;

330− if let Some(id) = &meta.id

331− && id.trim().is_empty()

332− {

333− meta.id = None;

334− }

335− if let Some(last_active) = &meta.last_active

336− && last_active.trim().is_empty()

337− {

338− meta.last_active = None;

339− }

340− Ok(meta)

341−}

342−

343293fn atomic_write(path: &Path, content: &[u8]) -> io::Result<()> {

344294 let Some(parent) = path.parent() else {

345295 return Err(io::Error::new(

@@ -362,6 +312,7 @@ fn atomic_write(path: &Path, content: &[u8]) -> io::Result<()> {

362312#[cfg(test)]

363313mod tests {

364314 use super::*;

315+ use crate::instance::{InstanceConfig, write_instance_config};

365316 use std::fs;

366317 use tempfile::TempDir;

367318

@@ -375,11 +326,14 @@ mod tests {

375326 dir

376327 }

377328

378− fn write_instance(project_dir: &Path, id: &str, last_active: &str) {

379− let instance_dir = project_dir.join(INSTANCE_DIR_NAME);

380− fs::create_dir_all(&instance_dir).unwrap();

381− let content = format!("id = \"{id}\"\nlast_active = \"{last_active}\"\n");

382− fs::write(instance_dir.join(INSTANCE_FILENAME), content).unwrap();

329+ fn write_instance(project_dir: &Path, id: &str, last_active: &str) -> Result<()> {

330+ fs::create_dir_all(project_dir)?;

331+

332+ let mut config = InstanceConfig::default();

333+ config.id = id.to_string();

334+ config.last_active = Some(last_active.to_string());

335+

336+ write_instance_config(project_dir, &config)

383337 }

384338

385339 #[test]

@@ -387,11 +341,14 @@ mod tests {

387341 let temp = TempDir::new().unwrap();

388342 let mgr = manager(&temp);

389343 let project_dir = create_project_dir(&temp);

390− fs::write(project_dir.join(CONFIG_FILENAME), "").unwrap();

391− write_instance(

392− &project_dir,

393− "019bf290-cccc-7c23-ba1d-dce7e6d40693",

394− "2026-02-07T05:00:00Z",

344+ fs::write(config_path(project_dir.as_path()), "").unwrap();

345+ assert!(

346+ write_instance(

347+ &project_dir,

348+ "019bf290-cccc-7c23-ba1d-dce7e6d40693",

349+ "2026-02-07T05:00:00Z",

350+ )

351+ .is_ok()

395352 );

396353

397354 let dirs = mgr.update_global_sessions(&project_dir).unwrap();

@@ -412,15 +369,18 @@ mod tests {

412369 let temp = TempDir::new().unwrap();

413370 let mgr = manager(&temp);

414371 let project_dir = create_project_dir(&temp);

415− fs::write(project_dir.join(CONFIG_FILENAME), "").unwrap();

416− write_instance(

417− &project_dir,

418− "019bf290-cccc-7c23-ba1d-dce7e6d40693",

419− "2026-02-07T05:00:00Z",

372+ fs::write(config_path(project_dir.as_path()), "").unwrap();

373+ assert!(

374+ write_instance(

375+ &project_dir,

376+ "019bf290-cccc-7c23-ba1d-dce7e6d40693",

377+ "2026-02-07T05:00:00Z",

378+ )

379+ .is_ok()

420380 );

421381 let _ = mgr.update_global_sessions(&project_dir).unwrap();

422382

423− fs::remove_file(project_dir.join(CONFIG_FILENAME)).unwrap();

383+ fs::remove_file(config_path(project_dir.as_path())).unwrap();

424384 let sessions = mgr.list_sessions().unwrap();

425385 assert!(sessions.is_empty());

426386

@@ -451,11 +411,14 @@ mod tests {

451411 let temp = TempDir::new().unwrap();

452412 let mgr = manager(&temp);

453413 let project_dir = create_project_dir(&temp);

454− fs::write(project_dir.join(CONFIG_FILENAME), "").unwrap();

455− write_instance(

456− &project_dir,

457− "019bf290-cccc-7c23-ba1d-dce7e6d40693",

458− "2026-02-07T05:00:00Z",

414+ fs::write(config_path(project_dir.as_path()), "").unwrap();

415+ assert!(

416+ write_instance(

417+ &project_dir,

418+ "019bf290-cccc-7c23-ba1d-dce7e6d40693",

419+ "2026-02-07T05:00:00Z",

420+ )

421+ .is_ok()

459422 );

460423 let _ = mgr.update_global_sessions(&project_dir).unwrap();

461424

src/ssh.sh+18−10

@@ -2,6 +2,7 @@

22set -eu

44SSH_USER="__SSH_USER__"

5+SUDO_PASSWORD="__SUDO_PASSWORD__"

56PROJECT_NAME="__PROJECT_NAME__"

67PROJECT_GUEST_DIR="__PROJECT_GUEST_DIR__"

78KEY_PATH="__KEY_PATH__"

@@ -61,6 +62,10 @@ if ! id -u "$SSH_USER" >/dev/null 2>&1; then

6162 usermod -aG sudo "$SSH_USER" || true

6263fi

6364

65+if [ -n "$SUDO_PASSWORD" ]; then

66+ echo "${SSH_USER}:${SUDO_PASSWORD}" | chpasswd

67+fi

68+

6469install -d -m 700 -o "$SSH_USER" -g "$SSH_USER" "/home/${SSH_USER}/.ssh"

6570install -m 600 -o "$SSH_USER" -g "$SSH_USER" "$KEY_PATH" "/home/${SSH_USER}/.ssh/authorized_keys"

6671

@@ -109,8 +114,8 @@ mise_ok() { command -v mise >/dev/null 2>&1 || [ -x "$MISE_BIN" ]; }

109114mise_install() {

110115 if [ ! -x "$MISE_BIN" ] && ! command -v mise >/dev/null 2>&1; then

111116 if ! curl https://mise.run | HOME="$USER_HOME" sh; then

112− mise_warn "mise install script failed (continuing)"

113− return 0

117+ mise_warn "mise install script failed"

118+ return 1

114119 fi

115120 fi

116121 echo 'eval "$(~/.local/bin/mise activate bash)"' >> "${USER_HOME}/.bashrc"

@@ -136,18 +141,21 @@ MISE

136141 touch "${USER_HOME}/.config/mise/mise.lock"

137142 if [ -x "$MISE_BIN" ]; then

138143 if ! HOME="$USER_HOME" "$MISE_BIN" install; then

139− mise_warn "mise install failed (continuing)"

140− return 0

144+ mise_warn "mise install failed"

145+ return 1

141146 fi

142147 else

143148 if ! HOME="$USER_HOME" mise install; then

144− mise_warn "mise install failed (continuing)"

145− return 0

149+ mise_warn "mise install failed"

150+ return 1

146151 fi

147152 fi

148153}

149154

150−mise_install || true

155+if ! mise_install; then

156+ diag "mise installation failed"

157+ vibebox_fail "mise installation failed" 1

158+fi

151159

152160# 3) start ssh (don't swallow failures)

153161# If ssh is already active, don't force start/restart.

@@ -155,7 +163,7 @@ if ! systemctl is-active --quiet ssh; then

155163 if ! systemctl start ssh; then

156164 diag "systemctl start ssh failed"

157165 dump_diag

158− exit 1

166+ vibebox_fail "failed to start ssh service" 1

159167 fi

160168fi

161169

@@ -193,7 +201,7 @@ done

193201if [ -z "$dev" ] || [ -z "$ip" ]; then

194202 diag "no stable IPv4 on default route interface"

195203 dump_diag

196− exit 1

204+ vibebox_fail "no stable ipv4 route on default interface" 1

197205fi

198206

199207# 5) strong verify: ssh must listen externally (0.0.0.0:22 or $ip:22 or [::]:22)

@@ -212,7 +220,7 @@ done

212220if ! listens_ok; then

213221 diag "sshd not listening on 0.0.0.0:22 / ${ip}:22"

214222 dump_diag

215− exit 1

223+ vibebox_fail "sshd is not listening on the expected address" 1

216224fi

217225

218226ip a

src/tui.rs+31−31

@@ -1,10 +1,4 @@

1−use std::{

2− io::{self, Write},

3− os::unix::io::OwnedFd,

4− path::PathBuf,

5− sync::{Arc, Mutex},

6−};

7−

1+use bytesize::ByteSize;

82use color_eyre::Result;

93use crossterm::{

104 cursor::{MoveTo, Show},

@@ -22,6 +16,12 @@ use ratatui::{

2216 text::{Line, Span, Text},

2317 widgets::{Block, Borders, Cell, List, ListItem, Paragraph, Row, Table, Widget},

2418};

19+use std::{

20+ io::{self, Write},

21+ os::unix::io::OwnedFd,

22+ path::PathBuf,

23+ sync::{Arc, Mutex},

24+};

2525

2626use crate::vm;

2727

@@ -39,9 +39,9 @@ const INFO_LINE_COUNT: u16 = 5;

3939

4040#[derive(Debug, Clone)]

4141pub struct VmInfo {

42− pub max_memory_mb: u64,

42+ pub max_memory: ByteSize,

4343 pub cpu_cores: usize,

44− pub max_disk_gb: f32,

44+ pub max_disk: ByteSize,

4545 pub system_name: String,

4646 pub auto_shutdown_ms: u64,

4747}

@@ -474,27 +474,27 @@ fn write_buffer_with_style(buffer: &Buffer, out: &mut impl Write) -> io::Result<

474474 Ok(())

475475}

476476

477−fn map_color(color: ratatui::style::Color) -> CrosstermColor {

477+fn map_color(color: Color) -> CrosstermColor {

478478 match color {

479− ratatui::style::Color::Reset => CrosstermColor::Reset,

480− ratatui::style::Color::Black => CrosstermColor::Black,

481− ratatui::style::Color::Red => CrosstermColor::DarkRed,

482− ratatui::style::Color::Green => CrosstermColor::DarkGreen,

483− ratatui::style::Color::Yellow => CrosstermColor::DarkYellow,

484− ratatui::style::Color::Blue => CrosstermColor::DarkBlue,

485− ratatui::style::Color::Magenta => CrosstermColor::DarkMagenta,

486− ratatui::style::Color::Cyan => CrosstermColor::DarkCyan,

487− ratatui::style::Color::Gray => CrosstermColor::Grey,

488− ratatui::style::Color::DarkGray => CrosstermColor::DarkGrey,

489− ratatui::style::Color::LightRed => CrosstermColor::Red,

490− ratatui::style::Color::LightGreen => CrosstermColor::Green,

491− ratatui::style::Color::LightYellow => CrosstermColor::Yellow,

492− ratatui::style::Color::LightBlue => CrosstermColor::Blue,

493− ratatui::style::Color::LightMagenta => CrosstermColor::Magenta,

494− ratatui::style::Color::LightCyan => CrosstermColor::Cyan,

495− ratatui::style::Color::White => CrosstermColor::White,

496− ratatui::style::Color::Rgb(r, g, b) => CrosstermColor::Rgb { r, g, b },

497− ratatui::style::Color::Indexed(i) => CrosstermColor::AnsiValue(i),

479+ Color::Reset => CrosstermColor::Reset,

480+ Color::Black => CrosstermColor::Black,

481+ Color::Red => CrosstermColor::DarkRed,

482+ Color::Green => CrosstermColor::DarkGreen,

483+ Color::Yellow => CrosstermColor::DarkYellow,

484+ Color::Blue => CrosstermColor::DarkBlue,

485+ Color::Magenta => CrosstermColor::DarkMagenta,

486+ Color::Cyan => CrosstermColor::DarkCyan,

487+ Color::Gray => CrosstermColor::Grey,

488+ Color::DarkGray => CrosstermColor::DarkGrey,

489+ Color::LightRed => CrosstermColor::Red,

490+ Color::LightGreen => CrosstermColor::Green,

491+ Color::LightYellow => CrosstermColor::Yellow,

492+ Color::LightBlue => CrosstermColor::Blue,

493+ Color::LightMagenta => CrosstermColor::Magenta,

494+ Color::LightCyan => CrosstermColor::Cyan,

495+ Color::White => CrosstermColor::White,

496+ Color::Rgb(r, g, b) => CrosstermColor::Rgb { r, g, b },

497+ Color::Indexed(i) => CrosstermColor::AnsiValue(i),

498498 }

499499}

500500

@@ -574,8 +574,8 @@ fn render_header(buffer: &mut Buffer, area: Rect, app: &AppState) {

574574 Span::raw("CPU / Memory / Disk: "),

575575 Span::styled(

576576 format!(

577− "{} cores / {} MB / {} GB",

578− app.vm_info.cpu_cores, app.vm_info.max_memory_mb, app.vm_info.max_disk_gb

577+ "{} cores / {} / {}",

578+ app.vm_info.cpu_cores, app.vm_info.max_memory, app.vm_info.max_disk

579579 ),

580580 Style::default().fg(Color::Green),

581581 ),

src/utils.rsnew file+18

@@ -0,0 +1,18 @@

1+use std::{

2+ env,

3+ path::{Path, PathBuf},

4+};

6+pub fn relative_to_home(directory: &Path) -> String {

7+ let Ok(home) = env::var("HOME") else {

8+ return directory.display().to_string();

9+ };

10+ let home_path = PathBuf::from(home);

11+ if let Ok(stripped) = directory.strip_prefix(&home_path) {

12+ if stripped.components().next().is_none() {

13+ return "~".to_string();

14+ }

15+ return format!("~/{}", stripped.display());

16+ }

17+ directory.display().to_string()

18+}

src/vm.rs+179−161

@@ -1,5 +1,5 @@

1−use crate::instance::STATUS_FILE_NAME;

21use crate::session_manager::{GLOBAL_CACHE_DIR_NAME, INSTANCE_DIR_NAME};

2+use anyhow::{Context, Error, Result, bail};

33use std::{

44 env, fs,

55 io::{self, Write},

@@ -23,6 +23,7 @@ use std::{

2323};

2424

2525use block2::RcBlock;

26+use bytesize::ByteSize;

2627use dispatch2::DispatchQueue;

2728use objc2::{AnyThread, rc::Retained, runtime::ProtocolObject};

2829use objc2_foundation::*;

@@ -34,49 +35,19 @@ const DEBIAN_COMPRESSED_SIZE_BYTES: u64 = 280901576;

3435const SHARED_DIRECTORIES_TAG: &str = "shared";

3536pub const PROJECT_GUEST_BASE: &str = "/usr/local/vibebox-mounts";

3637

37−const BYTES_PER_MB: u64 = 1024 * 1024;

38−const DEFAULT_CPU_COUNT: usize = 2;

39−const DEFAULT_RAM_MB: u64 = 2048;

40−const DEFAULT_RAM_BYTES: u64 = DEFAULT_RAM_MB * BYTES_PER_MB;

4138const START_TIMEOUT: Duration = Duration::from_secs(60);

4239const LOGIN_EXPECT_TIMEOUT: Duration = Duration::from_secs(120);

4340const PROVISION_EXPECT_TIMEOUT: Duration = Duration::from_secs(900);

4441

45−struct StatusFile {

46− path: PathBuf,

47− cleared: AtomicBool,

48−}

49−

50−impl StatusFile {

51− fn new(path: PathBuf) -> Self {

52− Self {

53− path,

54− cleared: AtomicBool::new(false),

55− }

56− }

57−

58− fn update(&self, message: &str) {

59− let _ = fs::write(&self.path, message);

60− }

61−}

62−

63−impl Drop for StatusFile {

64− fn drop(&mut self) {

65− if !self.cleared.load(Ordering::SeqCst) {

66− let _ = fs::remove_file(&self.path);

67− self.cleared.store(true, Ordering::SeqCst);

68− }

69− }

70−}

42+const ERROR_REPORT_SCRIPT: &str = include_str!("error_report.sh");

7143const PROVISION_SCRIPT: &str = include_str!("provision.sh");

72−const PROVISION_SCRIPT_NAME: &str = "provision.sh";

7344const RESIZE_DISK_SCRIPT: &str = include_str!("resize_disk.sh");

7445const DEFAULT_RAW_NAME: &str = "default.raw";

7546const INSTANCE_RAW_NAME: &str = "instance.raw";

7647const BASE_DISK_RAW_NAME: &str = "disk.raw";

7748

7849#[derive(Clone)]

79−pub(crate) enum LoginAction {

50+pub enum LoginAction {

8051 Expect {

8152 text: String,

8253 timeout: Duration,

@@ -88,23 +59,20 @@ pub(crate) enum LoginAction {

8859 },

8960 Send(String),

9061}

62+use crate::config::BoxConfig;

9163use LoginAction::*;

9264

9365#[derive(Clone)]

94−pub(crate) struct DirectoryShare {

66+pub struct DirectoryShare {

9567 host: PathBuf,

9668 guest: PathBuf,

9769 read_only: bool,

9870}

9971

10072impl DirectoryShare {

101− pub(crate) fn new(

102− host: PathBuf,

103− mut guest: PathBuf,

104− read_only: bool,

105− ) -> Result<Self, Box<dyn std::error::Error>> {

73+ pub fn new(host: PathBuf, mut guest: PathBuf, read_only: bool) -> Result<Self> {

10674 if !host.exists() {

107− return Err(format!("Host path does not exist: {}", host.display()).into());

75+ bail!(format!("host path does not exist: {}", host.display()));

10876 }

10977 if !guest.is_absolute() {

11078 guest = PathBuf::from("/root").join(guest);

@@ -116,10 +84,10 @@ impl DirectoryShare {

11684 })

11785 }

11886

119− pub(crate) fn from_mount_spec(spec: &str) -> Result<Self, Box<dyn std::error::Error>> {

87+ pub fn from_mount_spec(spec: &str) -> Result<Self> {

12088 let parts: Vec<&str> = spec.split(':').collect();

12189 if parts.len() < 2 || parts.len() > 3 {

122− return Err(format!("Invalid mount spec: {spec}").into());

90+ bail!(format!("invalid mount spec: {spec}"));

12391 }

12492 let host = expand_tilde_path(parts[0]);

12593 let guest = PathBuf::from(parts[1]);

@@ -128,11 +96,10 @@ impl DirectoryShare {

12896 "read-only" => true,

12997 "read-write" => false,

13098 _ => {

131− return Err(format!(

99+ bail!(format!(

132100 "Invalid mount mode '{}'; expected read-only or read-write",

133101 parts[2]

134− )

135− .into());

102+ ));

136103 }

137104 }

138105 } else {

@@ -176,19 +143,28 @@ pub struct VmArg {

176143 pub mounts: Vec<String>,

177144}

178145

179−pub fn run_with_args<F>(args: VmArg, io_handler: F) -> Result<(), Box<dyn std::error::Error>>

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);

151+ }

152+}

153+

154+pub fn run_with_args<F>(args: VmArg, io_handler: F) -> Result<()>

180155where

181156 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,

182157{

183− run_with_args_and_extras(args, io_handler, Vec::new(), Vec::new())

158+ run_with_args_and_extras(args, io_handler, Vec::new(), Vec::new(), None)

184159}

185160

186−pub(crate) fn run_with_args_and_extras<F>(

161+pub fn run_with_args_and_extras<F>(

187162 args: VmArg,

188163 io_handler: F,

189164 extra_login_actions: Vec<LoginAction>,

190165 extra_directory_shares: Vec<DirectoryShare>,

191−) -> Result<(), Box<dyn std::error::Error>>

166+ status: Option<&StatusEmitter<'_>>,

167+) -> Result<()>

192168where

193169 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,

194170{

@@ -197,7 +173,7 @@ where

197173 let project_root = env::current_dir()?;

198174 let project_name = project_root

199175 .file_name()

200− .ok_or("Project directory has no name")?

176+ .with_context(|| "Project directory has no name")?

201177 .to_string_lossy()

202178 .into_owned();

203179

@@ -209,8 +185,10 @@ where

209185 let guest_mise_cache = cache_dir.join(".guest-mise-cache");

210186

211187 let instance_dir = project_root.join(INSTANCE_DIR_NAME);

212− let status_file = StatusFile::new(instance_dir.join(STATUS_FILE_NAME));

213− status_file.update("preparing VM image...");

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");

214192

215193 let basename_compressed = DEBIAN_COMPRESSED_DISK_URL.rsplit('/').next().unwrap();

216194 let base_compressed = cache_dir.join(basename_compressed);

@@ -234,13 +212,14 @@ where

234212 &base_compressed,

235213 &default_raw,

236214 std::slice::from_ref(&mise_directory_share),

237− Some(&status_file),

215+ Some(&provision_log),

216+ status,

238217 )?;

239218 let _ = ensure_instance_disk(

240219 &instance_raw,

241220 &default_raw,

242− args.disk_bytes,

243− Some(&status_file),

221+ ByteSize(args.disk_bytes),

222+ status,

244223 )?;

245224 let base_size = fs::metadata(&default_raw)?.len();

246225 let instance_size = fs::metadata(&instance_raw)?.len();

@@ -270,7 +249,7 @@ where

270249 }

271250

272251 if needs_resize {

273− let resize_cmd = script_command_from_content("resize_disk", RESIZE_DISK_SCRIPT)?;

252+ let resize_cmd = script_command_from_content("resize_disk.sh", RESIZE_DISK_SCRIPT)?;

274253 login_actions.push(Send(resize_cmd));

275254 }

276255

@@ -286,25 +265,29 @@ where

286265 &directory_shares[..],

287266 args.cpu_count,

288267 args.ram_bytes,

289− Some(&status_file),

268+ status,

290269 io_handler,

291270 )

292271}

293272

294−pub(crate) fn script_command_from_content(

295− label: &str,

296− script: &str,

297−) -> Result<String, Box<dyn std::error::Error>> {

273+pub fn script_command_from_content(label: &str, script: &str) -> Result<String> {

298274 let marker = "VIBE_SCRIPT_EOF";

299275 let guest_dir = "/tmp/vibe-scripts";

300276 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);

301284 let command = format!(

302− "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}"

303286 );

304287 if script.contains(marker) {

305− return Err(

306− format!("Script '{label}' contains marker '{marker}', cannot safely upload").into(),

307− );

288+ bail!(format!(

289+ "Script '{label}' contains marker '{marker}', cannot safely upload"

290+ ));

308291 }

309292 Ok(command)

310293}

@@ -501,18 +484,16 @@ impl IoControl {

501484fn ensure_base_image(

502485 base_raw: &Path,

503486 base_compressed: &Path,

504− status: Option<&StatusFile>,

505−) -> Result<(), Box<dyn std::error::Error>> {

487+ status: Option<&StatusEmitter<'_>>,

488+) -> Result<()> {

506489 if base_raw.exists() {

507490 return Ok(());

508491 }

509492

510493 if !base_compressed.exists()

511− || 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

512495 {

513− if let Some(status) = status {

514− status.update("downloading base image...");

515− }

496+ emit_status(status, "downloading base image...");

516497 tracing::info!("downloading base image");

517498 let status = Command::new("curl")

518499 .args([

@@ -527,15 +508,14 @@ fn ensure_base_image(

527508 ])

528509 .status()?;

529510 if !status.success() {

530− return Err("Failed to download base image".into());

511+ bail!("failed to download base image");

531512 }

532513 }

533514

534515 // Check SHA

535516 {

536− if let Some(status) = status {

537− status.update("verifying base image...");

538− }

517+ emit_status(status, "verifying base image...");

518+ tracing::info!("verifying base image...");

539519 let input = format!("{} {}\n", DEBIAN_COMPRESSED_SHA, base_compressed.display());

540520

541521 let mut child = Command::new("/usr/bin/shasum")

@@ -553,25 +533,25 @@ fn ensure_base_image(

553533

554534 let status = child.wait().expect("failed to wait on child");

555535 if !status.success() {

556− 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+ ));

557539 }

558540 }

559541

560− if let Some(status) = status {

561− status.update("decompressing base image...");

562− }

563− tracing::info!("decompressing base image");

542+ emit_status(status, "decompressing base image...");

543+ tracing::info!("decompressing base image...");

564544 let status = Command::new("tar")

565545 .args([

566546 "-xOf",

567547 &base_compressed.to_string_lossy(),

568548 BASE_DISK_RAW_NAME,

569549 ])

570− .stdout(std::fs::File::create(base_raw)?)

550+ .stdout(fs::File::create(base_raw)?)

571551 .status()?;

572552

573553 if !status.success() {

574− return Err("Failed to decompress base image".into());

554+ bail!("Failed to decompress base image");

575555 }

576556

577557 Ok(())

@@ -582,21 +562,20 @@ fn ensure_default_image(

582562 base_compressed: &Path,

583563 default_raw: &Path,

584564 directory_shares: &[DirectoryShare],

585− status: Option<&StatusFile>,

586−) -> Result<(), Box<dyn std::error::Error>> {

565+ provision_log: Option<&Path>,

566+ status: Option<&StatusEmitter<'_>>,

567+) -> Result<()> {

587568 if default_raw.exists() {

588569 return Ok(());

589570 }

590571

591572 ensure_base_image(base_raw, base_compressed, status)?;

592573

593− if let Some(status) = status {

594− status.update("configuring base image...");

595− }

596− tracing::info!("configuring base image");

574+ emit_status(status, "configuring base image...");

575+ tracing::info!("configuring base image...");

597576 fs::copy(base_raw, default_raw)?;

598577

599− let provision_command = script_command_from_content(PROVISION_SCRIPT_NAME, PROVISION_SCRIPT)?;

578+ let provision_command = script_command_from_content("provision.sh", PROVISION_SCRIPT)?;

600579 let provision_actions = [

601580 Send(provision_command),

602581 ExpectEither {

@@ -605,14 +584,31 @@ fn ensure_default_image(

605584 timeout: PROVISION_EXPECT_TIMEOUT,

606585 },

607586 ];

608− if let Err(err) = run_vm(

609− default_raw,

610− &provision_actions,

611− directory_shares,

612− DEFAULT_CPU_COUNT,

613− DEFAULT_RAM_BYTES,

614− None,

615− ) {

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 {

616612 let _ = fs::remove_file(default_raw);

617613 return Err(err);

618614 }

@@ -623,18 +619,16 @@ fn ensure_default_image(

623619fn ensure_instance_disk(

624620 instance_raw: &Path,

625621 template_raw: &Path,

626− target_bytes: u64,

627− status: Option<&StatusFile>,

628−) -> Result<bool, Box<dyn std::error::Error>> {

622+ target_bytes: ByteSize,

623+ status: Option<&StatusEmitter<'_>>,

624+) -> Result<bool> {

629625 if instance_raw.exists() {

630− let current_size = fs::metadata(instance_raw)?.len();

626+ let current_size = ByteSize(fs::metadata(instance_raw)?.len());

631627 if current_size != target_bytes {

632− let current_gb = current_size as f64 / (1024.0 * 1024.0 * 1024.0);

633− let target_gb = target_bytes as f64 / (1024.0 * 1024.0 * 1024.0);

628+ let current_gb = current_size;

629+ let target_gb = target_bytes;

634630 tracing::warn!(

635− current_bytes = current_size,

636− target_bytes,

637− "instance disk size does not match config (current {:.2} GB, config {:.2} GB); disk_gb applies only on init. Run `vibebox reset` to recreate or set disk_gb to match; using existing disk.",

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.",

638632 current_gb,

639633 target_gb

640634 );

@@ -642,30 +636,28 @@ fn ensure_instance_disk(

642636 return Ok(false);

643637 }

644638

645− let template_size = fs::metadata(template_raw)?.len();

639+ let template_size = ByteSize(fs::metadata(template_raw)?.len());

646640 if target_bytes < template_size {

647− return Err(format!(

648− "Requested disk size {} bytes is smaller than base image size {} bytes",

641+ bail!(format!(

642+ "Requested disk size {} is smaller than base image size {}",

649643 target_bytes, template_size

650− )

651− .into());

644+ ));

652645 }

653646 let target_size = target_bytes;

654647 let needs_resize = target_size > template_size;

655648

656− if let Some(status) = status {

657− status.update("creating instance disk...");

658− }

649+ emit_status(status, "creating instance disk...");

650+ tracing::info!("creating instance disk...");

659651 tracing::info!(path = %template_raw.display(), "creating instance disk");

660− std::fs::create_dir_all(instance_raw.parent().unwrap())?;

652+ fs::create_dir_all(instance_raw.parent().unwrap())?;

661653 if target_size == template_size {

662654 fs::copy(template_raw, instance_raw)?;

663655 return Ok(needs_resize);

664656 }

665657

666− let mut dst = std::fs::File::create(instance_raw)?;

667− dst.set_len(target_size)?;

668− let mut src = std::fs::File::open(template_raw)?;

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)?;

669661 std::io::copy(&mut src, &mut dst)?;

670662 Ok(needs_resize)

671663}

@@ -683,18 +675,17 @@ pub fn create_pipe() -> (OwnedFd, OwnedFd) {

683675 (read_stream.into(), write_stream.into())

684676}

685677

686−pub fn spawn_vm_io_with_hooks<F, G>(

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+>(

687682 output_monitor: Arc<OutputMonitor>,

688683 vm_output_fd: OwnedFd,

689684 vm_input_fd: OwnedFd,

690685 io_control: Arc<IoControl>,

691686 mut on_line: F,

692687 mut on_output: G,

693−) -> IoContext

694−where

695− F: FnMut(&str) -> bool + ::std::marker::Send + 'static,

696− G: FnMut(&[u8]) + ::std::marker::Send + 'static,

697−{

688+) -> IoContext {

698689 let (input_tx, input_rx): (Sender<VmInput>, Receiver<VmInput>) = mpsc::channel();

699690

700691 // raw_guard is set when we've put the user's terminal into raw mode because we've attached stdin/stdout to the VM.

@@ -842,14 +833,14 @@ where

842833 PollResult::Spurious => continue,

843834 PollResult::Ready(bytes) => {

844835 if io_control.forward_output() {

845− // enable raw mode, if we haven't already

836+ // enable raw mode if we haven't already

846837 if raw_guard.lock().unwrap().is_none()

847838 && let Ok(guard) = enable_raw_mode(libc::STDIN_FILENO)

848839 {

849840 *raw_guard.lock().unwrap() = Some(guard);

850841 }

851842

852− let mut stdout = std::io::stdout().lock();

843+ let mut stdout = io::stdout().lock();

853844 if stdout.write_all(bytes).is_err() {

854845 break;

855846 }

@@ -865,7 +856,7 @@ where

865856

866857 // Copies data from mpsc channel into VM, so vibe can "type" stuff and run scripts.

867858 let mux_thread = thread::spawn(move || {

868− let mut vm_writer = std::fs::File::from(vm_input_fd);

859+ let mut vm_writer = fs::File::from(vm_input_fd);

869860 loop {

870861 match input_rx.recv() {

871862 Ok(VmInput::Bytes(data)) => {

@@ -895,7 +886,7 @@ pub fn spawn_vm_io_with_line_handler<F>(

895886 on_line: F,

896887) -> IoContext

897888where

898− F: FnMut(&str) -> bool + ::std::marker::Send + 'static,

889+ F: FnMut(&str) -> bool + std::marker::Send + 'static,

899890{

900891 spawn_vm_io_with_hooks(

901892 output_monitor,

@@ -915,6 +906,36 @@ pub fn spawn_vm_io(

915906 spawn_vm_io_with_line_handler(output_monitor, vm_output_fd, vm_input_fd, |_| false)

916907}

917908

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+

918939impl IoContext {

919940 pub fn shutdown(self) {

920941 let _ = self.input_tx.send(VmInput::Shutdown);

@@ -932,7 +953,7 @@ fn create_vm_configuration(

932953 vm_writes_to_fd: OwnedFd,

933954 cpu_count: usize,

934955 ram_bytes: u64,

935−) -> Result<Retained<VZVirtualMachineConfiguration>, Box<dyn std::error::Error>> {

956+) -> Result<Retained<VZVirtualMachineConfiguration>> {

936957 unsafe {

937958 let platform =

938959 VZGenericPlatformConfiguration::init(VZGenericPlatformConfiguration::alloc());

@@ -966,7 +987,7 @@ fn create_vm_configuration(

966987 false,

967988 VZDiskImageCachingMode::Automatic,

968989 VZDiskImageSynchronizationMode::Full,

969− ).unwrap();

990+ )?;

970991

971992 let disk_device = VZVirtioBlockDeviceConfiguration::initWithAttachment(

972993 VZVirtioBlockDeviceConfiguration::alloc(),

@@ -1053,7 +1074,7 @@ fn create_vm_configuration(

10531074 // Validate

10541075 config.validateWithError().map_err(|e| {

10551076 io::Error::other(format!(

1056− "Invalid VM configuration: {:?}",

1077+ "invalid VM configuration: {:?}",

10571078 e.localizedDescription()

10581079 ))

10591080 })?;

@@ -1062,9 +1083,9 @@ fn create_vm_configuration(

10621083 }

10631084}

10641085

1065−fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>, Box<dyn std::error::Error>> {

1086+fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>> {

10661087 unsafe {

1067− let temp_dir = std::env::temp_dir();

1088+ let temp_dir = env::temp_dir();

10681089 let temp_path = temp_dir.join(format!("efi_variable_store_{}.efivars", std::process::id()));

10691090 let url = nsurl_from_path(&temp_path)?;

10701091 let options = VZEFIVariableStoreInitializationOptions::AllowOverwrite;

@@ -1080,8 +1101,8 @@ fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>, Box<dyn std

10801101fn spawn_login_actions_thread(

10811102 login_actions: Vec<LoginAction>,

10821103 output_monitor: Arc<OutputMonitor>,

1083− input_tx: mpsc::Sender<VmInput>,

1084− vm_output_tx: mpsc::Sender<VmOutput>,

1104+ input_tx: Sender<VmInput>,

1105+ vm_output_tx: Sender<VmOutput>,

10851106) -> thread::JoinHandle<()> {

10861107 thread::spawn(move || {

10871108 for a in login_actions {

@@ -1131,9 +1152,9 @@ fn run_vm_with_io<F>(

11311152 directory_shares: &[DirectoryShare],

11321153 cpu_count: usize,

11331154 ram_bytes: u64,

1134− status: Option<&StatusFile>,

1155+ status: Option<&StatusEmitter<'_>>,

11351156 io_handler: F,

1136−) -> Result<(), Box<dyn std::error::Error>>

1157+) -> Result<()>

11371158where

11381159 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,

11391160{

@@ -1180,23 +1201,22 @@ where

11801201

11811202 match rx.try_recv() {

11821203 Ok(result) => {

1183− result.map_err(|e| format!("Failed to start VM: {}", e))?;

1204+ result.map_err(|e| Error::msg(format!("Failed to start VM: {}", e)))?;

11841205 break;

11851206 }

11861207 Err(mpsc::TryRecvError::Empty) => continue,

11871208 Err(mpsc::TryRecvError::Disconnected) => {

1188− return Err("VM start channel disconnected".into());

1209+ bail!("VM start channel disconnected");

11891210 }

11901211 }

11911212 }

11921213

11931214 if Instant::now() >= start_deadline {

1194− return Err("Timed out waiting for VM to start".into());

1215+ bail!("Timed out waiting for VM to start");

11951216 }

11961217

1197− if let Some(status) = status {

1198− status.update("vm booting... go vibecoder!");

1199− }

1218+ emit_status(status, "vm booting... go vibecoder!");

1219+ tracing::info!("vm booting... go vibecoder!");

12001220 tracing::info!("vm booting");

12011221

12021222 let output_monitor = Arc::new(OutputMonitor::default());

@@ -1242,7 +1262,7 @@ where

12421262 );

12431263

12441264 let mut last_state = None;

1245− let mut exit_result = Ok(());

1265+ let mut exit_result: Result<(), String> = Ok(());

12461266 loop {

12471267 unsafe {

12481268 NSRunLoop::mainRunLoop().runMode_beforeDate(

@@ -1261,8 +1281,7 @@ where

12611281 exit_result = Err(format!(

12621282 "Login action ({}) timed out after {:?}; shutting down.",

12631283 action, timeout

1264− )

1265− .into());

1284+ ));

12661285 unsafe {

12671286 if vm.canRequestStop() {

12681287 if let Err(err) = vm.requestStopWithError() {

@@ -1279,8 +1298,7 @@ where

12791298 exit_result = Err(format!(

12801299 "Login action ({}) failed: {}; shutting down.",

12811300 action, reason

1282− )

1283− .into());

1301+ ));

12841302 unsafe {

12851303 if vm.canRequestStop() {

12861304 if let Err(err) = vm.requestStopWithError() {

@@ -1296,7 +1314,7 @@ where

12961314 Err(mpsc::TryRecvError::Empty) => {}

12971315 Err(mpsc::TryRecvError::Disconnected) => {}

12981316 }

1299− if state != objc2_virtualization::VZVirtualMachineState::Running {

1317+ if state != VZVirtualMachineState::Running {

13001318 //eprintln!("VM stopped with state: {:?}", state);

13011319 break;

13021320 }

@@ -1306,7 +1324,7 @@ where

13061324

13071325 io_ctx.shutdown();

13081326

1309− exit_result

1327+ exit_result.map_err(Error::msg)

13101328}

13111329

13121330fn run_vm(

@@ -1315,8 +1333,8 @@ fn run_vm(

13151333 directory_shares: &[DirectoryShare],

13161334 cpu_count: usize,

13171335 ram_bytes: u64,

1318− status: Option<&StatusFile>,

1319−) -> Result<(), Box<dyn std::error::Error>> {

1336+ status: Option<&StatusEmitter<'_>>,

1337+) -> Result<()> {

13201338 run_vm_with_io(

13211339 disk_path,

13221340 login_actions,

@@ -1328,7 +1346,7 @@ fn run_vm(

13281346 )

13291347}

13301348

1331−fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>, Box<dyn std::error::Error>> {

1349+fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>> {

13321350 let abs_path = if path.is_absolute() {

13331351 path.to_path_buf()

13341352 } else {

@@ -1337,7 +1355,7 @@ fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>, Box<dyn std::error::E

13371355 let ns_path = NSString::from_str(

13381356 abs_path

13391357 .to_str()

1340− .ok_or("Non-UTF8 path encountered while building NSURL")?,

1358+ .with_context(|| "non-UTF8 path encountered while building NSURL")?,

13411359 );

13421360 Ok(NSURL::fileURLWithPath(&ns_path))

13431361}

@@ -1352,7 +1370,7 @@ fn enable_raw_mode(fd: i32) -> io::Result<RawModeGuard> {

13521370 let original = attributes;

13531371

13541372 // Disable translation of carriage return to newline on input

1355− attributes.c_iflag &= !(libc::ICRNL);

1373+ attributes.c_iflag &= !libc::ICRNL;

13561374 // Disable canonical mode (line buffering), echo, and signal generation

13571375 attributes.c_lflag &= !(libc::ICANON | libc::ECHO | libc::ISIG);

13581376 attributes.c_cc[libc::VMIN] = 0;

@@ -1380,10 +1398,10 @@ impl Drop for RawModeGuard {

13801398

13811399// Ensure the running binary has com.apple.security.virtualization entitlements by checking and, if not, signing and relaunching.

13821400pub fn ensure_signed() {

1383− if std::env::var("VIBEBOX_SKIP_CODESIGN").as_deref() == Ok("1") {

1401+ if env::var("VIBEBOX_SKIP_CODESIGN").as_deref() == Ok("1") {

13841402 return;

13851403 }

1386− let exe = std::env::current_exe().expect("failed to get current exe path");

1404+ let exe = env::current_exe().expect("failed to get current exe path");

13871405 let exe_str = exe.to_str().expect("exe path not valid utf-8");

13881406

13891407 let has_required_entitlements = {

@@ -1405,8 +1423,8 @@ pub fn ensure_signed() {

14051423 }

14061424

14071425 const ENTITLEMENTS: &str = include_str!("entitlements.plist");

1408− let entitlements_path = std::env::temp_dir().join("entitlements.plist");

1409− 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");

14101428

14111429 let output = Command::new("codesign")

14121430 .args([

@@ -1419,7 +1437,7 @@ pub fn ensure_signed() {

14191437 ])

14201438 .output();

14211439

1422− let _ = std::fs::remove_file(&entitlements_path);

1440+ let _ = fs::remove_file(&entitlements_path);

14231441

14241442 match output {

14251443 Ok(o) if o.status.success() => {

@@ -1427,7 +1445,7 @@ pub fn ensure_signed() {

14271445 if !stderr.trim().is_empty() {

14281446 tracing::debug!(codesign_stderr = %stderr.trim(), "codesign output");

14291447 }

1430− let err = Command::new(&exe).args(std::env::args_os().skip(1)).exec();

1448+ let err = Command::new(&exe).args(env::args_os().skip(1)).exec();

14311449 tracing::error!(error = %err, "failed to re-exec after signing");

14321450 std::process::exit(1);

14331451 }

src/vm_manager.rs+204−114

@@ -1,12 +1,22 @@

1+use crate::instance::{VmLiveness, vm_liveness};

2+use crate::session_manager::INSTANCE_DIR_NAME;

3+use crate::{

4+ config::CONFIG_PATH_ENV,

5+ instance::{

6+ InstanceConfig, STATUS_VM_ERROR_PREFIX, build_ssh_login_actions, ensure_instance_dir,

7+ ensure_ssh_keypair, extract_ipv4, load_or_create_instance_config, write_instance_config,

8+ },

9+ session_manager::{GLOBAL_DIR_NAME, VM_MANAGER_PID_NAME, VM_MANAGER_SOCKET_NAME},

10+ vm::{self, DirectoryShare, LoginAction, PROJECT_GUEST_BASE, VmInput},

11+};

12+use anyhow::{Error, Result, anyhow, bail};

113use std::{

214 env, fs,

315 io::{Read, Write},

416 os::unix::{

5− fs::FileTypeExt,

617 fs::PermissionsExt,

718 io::AsRawFd,

819 net::{UnixListener, UnixStream},

9− process::CommandExt,

1020 },

1121 path::{Path, PathBuf},

1222 process::{Command, Stdio},

@@ -15,20 +25,8 @@ use std::{

1525 time::{Duration, Instant},

1626};

1727

18−use crate::{

19− config::CONFIG_PATH_ENV,

20− instance::STATUS_FILE_NAME,

21− instance::VM_ROOT_LOG_NAME,

22− instance::{

23− DEFAULT_SSH_USER, InstanceConfig, build_ssh_login_actions, ensure_instance_dir,

24− ensure_ssh_keypair, extract_ipv4, load_or_create_instance_config, write_instance_config,

25− },

26− session_manager::{

27− GLOBAL_DIR_NAME, INSTANCE_FILENAME, VM_MANAGER_PID_NAME, VM_MANAGER_SOCKET_NAME,

28− },

29− vm::{self, DirectoryShare, LoginAction, PROJECT_GUEST_BASE, VmInput},

30−};

31−

28+#[cfg_attr(feature = "mock-vm", allow(dead_code))]

29+const VM_ROOT_LOG_NAME: &str = "vm_root.log";

3230const VM_MANAGER_LOCK_NAME: &str = "vm.lock";

3331const VM_MANAGER_LOG_NAME: &str = "vm_manager.log";

3432const SHUTDOWN_RETRY_MS: u64 = 500;

@@ -36,6 +34,10 @@ const SHUTDOWN_RETRY_MS: u64 = 500;

3634const HARD_SHUTDOWN_TIMEOUT_MS: u64 = 1_000;

3735#[cfg(not(test))]

3836const HARD_SHUTDOWN_TIMEOUT_MS: u64 = 12_000;

37+const STATUS_PREFIX: &str = "status:";

38+

39+type ClientStreams = Arc<Mutex<Vec<UnixStream>>>;

40+type SharedStatus = Arc<Mutex<String>>;

3941

4042#[cfg(not(test))]

4143fn force_exit(_reason: &str) -> ! {

@@ -51,16 +53,16 @@ pub fn ensure_manager(

5153 raw_args: &[std::ffi::OsString],

5254 auto_shutdown_ms: u64,

5355 config_path: Option<&Path>,

54−) -> Result<UnixStream, Box<dyn std::error::Error>> {

56+) -> Result<UnixStream> {

5557 let project_root = env::current_dir()?;

5658 tracing::debug!(root = %project_root.display(), "ensure vm manager");

5759 let instance_dir = ensure_instance_dir(&project_root)?;

58− cleanup_stale_manager(&instance_dir);

60+ cleanup_stale_manager(&project_root)?;

5961 let socket_path = instance_dir.join(VM_MANAGER_SOCKET_NAME);

6062

6163 if let Ok(stream) = UnixStream::connect(&socket_path) {

6264 send_client_pid(&stream);

63− tracing::info!(path = %socket_path.display(), "connected to existing vm manager");

65+ tracing::info!(path = %socket_path.display(), "connected to an existing vm manager");

6466 return Ok(stream);

6567 }

6668

@@ -98,12 +100,11 @@ pub fn ensure_manager(

98100 drop(lock_file.take());

99101 let _ = fs::remove_file(&lock_path);

100102 }

101− return Err(format!(

102− "Timed out waiting for vm manager socket: {} ({})",

103+ bail!(format!(

104+ "timed out waiting for vm manager socket: {} ({})",

103105 socket_path.display(),

104106 err

105− )

106− .into());

107+ ));

107108 }

108109 thread::sleep(Duration::from_millis(100));

109110 }

@@ -111,12 +112,19 @@ pub fn ensure_manager(

111112 }

112113}

113114

114−pub fn run_manager(

115− args: vm::VmArg,

116− auto_shutdown_ms: u64,

117−) -> Result<(), Box<dyn std::error::Error>> {

115+pub fn run_manager(args: vm::VmArg, auto_shutdown_ms: u64) -> Result<()> {

118116 let project_root = env::current_dir()?;

119117 tracing::info!(root = %project_root.display(), "vm manager starting");

118+ #[cfg(not(feature = "mock-vm"))]

119+ {

120+ unsafe {

121+ env::remove_var("VIBEBOX_SKIP_CODESIGN");

122+ }

123+ vm::ensure_signed();

124+ unsafe {

125+ env::set_var("VIBEBOX_SKIP_CODESIGN", "1");

126+ }

127+ }

120128 let _pid_guard = ensure_pid_file(&project_root)?;

121129 #[cfg(feature = "mock-vm")]

122130 tracing::info!("vm manager using mock executor");

@@ -134,7 +142,6 @@ pub fn run_manager(

134142 #[cfg(feature = "mock-vm")]

135143 {

136144 ManagerOptions {

137− ensure_signed: false,

138145 detach: true,

139146 prepare_vm: false,

140147 }

@@ -142,7 +149,6 @@ pub fn run_manager(

142149 #[cfg(not(feature = "mock-vm"))]

143150 {

144151 ManagerOptions {

145− ensure_signed: true,

146152 detach: true,

147153 prepare_vm: true,

148154 }

@@ -156,25 +162,22 @@ fn spawn_manager_process(

156162 auto_shutdown_ms: u64,

157163 instance_dir: &Path,

158164 config_path: Option<&Path>,

159−) -> Result<(), Box<dyn std::error::Error>> {

165+) -> Result<()> {

160166 let exe = env::current_exe()?;

161167 let mut supervisor_exe = exe.clone();

162168 supervisor_exe.set_file_name("vibebox-supervisor");

163− let use_supervisor = supervisor_exe.exists();

164− let mut cmd = if use_supervisor {

165− Command::new(supervisor_exe)

166− } else {

167− let mut cmd = Command::new(exe);

168− cmd.arg0("vibebox-supervisor");

169− cmd

170− };

169+ // intentional

170+ if !supervisor_exe.exists() {

171+ bail!(format!(

172+ "vibebox-supervisor not found at {}",

173+ supervisor_exe.display()

174+ ));

175+ }

176+ let mut cmd = Command::new(supervisor_exe);

171177 if raw_args.len() > 1 {

172178 cmd.args(&raw_args[1..]);

173179 }

174180 cmd.env("VIBEBOX_INTERNAL", "1");

175− if !use_supervisor {

176− cmd.env("VIBEBOX_VM_MANAGER", "1");

177− }

178181 cmd.env("VIBEBOX_LOG_NO_COLOR", "1");

179182 cmd.env("VIBEBOX_AUTO_SHUTDOWN_MS", auto_shutdown_ms.to_string());

180183 if let Some(path) = config_path {

@@ -202,22 +205,22 @@ fn spawn_manager_process(

202205 Ok(())

203206}

204207

205−fn ensure_pid_file(project_root: &Path) -> Result<PidFileGuard, Box<dyn std::error::Error>> {

208+fn ensure_pid_file(project_root: &Path) -> Result<PidFileGuard> {

206209 let instance_dir = ensure_instance_dir(project_root)?;

207210 let pid_path = instance_dir.join(VM_MANAGER_PID_NAME);

208211 let socket_path = instance_dir.join(VM_MANAGER_SOCKET_NAME);

209− if let Ok(content) = fs::read_to_string(&pid_path)

210− && let Ok(pid) = content.trim().parse::<u32>()

211− && pid_is_alive(pid)

212− {

213− if is_socket_path(&socket_path) {

214− return Err(format!("vm manager already running (pid {pid})").into());

212+ match vm_liveness(project_root)? {

213+ VmLiveness::RunningWithSocket { pid } => {

214+ bail!("vm manager already running (pid {pid})");

215215 }

216− tracing::warn!(

217− pid,

218− path = %socket_path.display(),

219− "stale pid file detected with missing socket"

220− );

216+ VmLiveness::RunningWithoutSocket { pid } => {

217+ tracing::warn!(

218+ pid,

219+ path = %socket_path.display(),

220+ "stale pid file detected with missing socket"

221+ );

222+ }

223+ VmLiveness::NotRunningOrMissing => {}

221224 }

222225 let _ = fs::remove_file(&pid_path);

223226 fs::write(&pid_path, format!("{}\n", std::process::id()))?;

@@ -225,15 +228,18 @@ fn ensure_pid_file(project_root: &Path) -> Result<PidFileGuard, Box<dyn std::err

225228 Ok(PidFileGuard { path: pid_path })

226229}

227230

228−fn cleanup_stale_manager(instance_dir: &Path) {

229− let pid_path = instance_dir.join(VM_MANAGER_PID_NAME);

230− if let Ok(content) = fs::read_to_string(&pid_path)

231− && let Ok(pid) = content.trim().parse::<u32>()

232− && pid_is_alive(pid)

233− {

234− return;

231+fn cleanup_stale_manager(project_root: &Path) -> Result<()> {

232+ let pid_path = project_root

233+ .join(INSTANCE_DIR_NAME)

234+ .join(VM_MANAGER_PID_NAME);

235+ if matches!(

236+ vm_liveness(project_root)?,

237+ VmLiveness::RunningWithSocket { .. } | VmLiveness::RunningWithoutSocket { .. }

238+ ) {

239+ return Ok(());

235240 }

236241 let _ = fs::remove_file(&pid_path);

242+ Ok(())

237243}

238244

239245fn inject_project_mount(

@@ -260,12 +266,6 @@ fn inject_project_mount(

260266 mounts.insert(0, format!("{host}:{guest_tilde}:read-write"));

261267}

262268

263−fn is_socket_path(path: &Path) -> bool {

264− fs::metadata(path)

265− .map(|meta| meta.file_type().is_socket())

266− .unwrap_or(false)

267−}

268−

269269fn prepare_mounts_and_links(mut args: vm::VmArg, ssh_user: &str) -> (vm::VmArg, String) {

270270 let mut links = Vec::new();

271271 let mut mounts = Vec::with_capacity(args.mounts.len());

@@ -409,6 +409,30 @@ fn wait_for_disconnect(mut stream: UnixStream) {

409409 }

410410}

411411

412+fn remove_client(streams: &ClientStreams, fd: std::os::fd::RawFd) {

413+ if let Ok(mut clients) = streams.lock() {

414+ clients.retain(|stream| stream.as_raw_fd() != fd);

415+ }

416+}

417+

418+fn send_status_line(stream: &mut UnixStream, status: &str) -> bool {

419+ let mut payload = String::with_capacity(STATUS_PREFIX.len() + status.len() + 1);

420+ payload.push_str(STATUS_PREFIX);

421+ payload.push_str(status);

422+ payload.push('\n');

423+ stream.write_all(payload.as_bytes()).is_ok()

424+}

425+

426+#[cfg_attr(feature = "mock-vm", allow(dead_code))]

427+fn broadcast_status(streams: &ClientStreams, latest_status: &SharedStatus, status: &str) {

428+ if let Ok(mut current) = latest_status.lock() {

429+ *current = status.to_string();

430+ }

431+ if let Ok(mut clients) = streams.lock() {

432+ clients.retain_mut(|stream| send_status_line(stream, status));

433+ }

434+}

435+

412436fn send_client_pid(stream: &UnixStream) {

413437 let pid = std::process::id();

414438 let payload = format!("pid={pid}\n");

@@ -418,7 +442,7 @@ fn send_client_pid(stream: &UnixStream) {

418442 }

419443}

420444

421−fn acquire_spawn_lock(lock_path: &Path) -> Result<Option<fs::File>, Box<dyn std::error::Error>> {

445+fn acquire_spawn_lock(lock_path: &Path) -> Result<Option<fs::File>> {

422446 match fs::OpenOptions::new()

423447 .write(true)

424448 .create_new(true)

@@ -452,6 +476,12 @@ fn is_lock_stale(lock_path: &Path) -> bool {

452476 }

453477}

454478

479+fn read_lock_pid(lock_path: &Path) -> Option<u32> {

480+ let content = fs::read_to_string(lock_path).ok()?;

481+ let line = content.lines().next()?;

482+ line.strip_prefix("pid=")?.trim().parse::<u32>().ok()

483+}

484+

455485fn pid_is_alive(pid: u32) -> bool {

456486 let pid = pid as libc::pid_t;

457487 let result = unsafe { libc::kill(pid, 0) };

@@ -465,12 +495,6 @@ fn pid_is_alive(pid: u32) -> bool {

465495 }

466496}

467497

468−fn read_lock_pid(lock_path: &Path) -> Option<u32> {

469− let content = fs::read_to_string(lock_path).ok()?;

470− let line = content.lines().next()?;

471− line.strip_prefix("pid=")?.trim().parse::<u32>().ok()

472−}

473−

474498fn read_client_pid(stream: &UnixStream) -> Option<u32> {

475499 let mut stream = stream.try_clone().ok()?;

476500 let _ = stream.set_read_timeout(Some(Duration::from_millis(200)));

@@ -506,12 +530,14 @@ fn read_client_pid(stream: &UnixStream) -> Option<u32> {

506530#[cfg_attr(feature = "mock-vm", allow(dead_code))]

507531fn spawn_manager_io(

508532 config: Arc<Mutex<InstanceConfig>>,

509− instance_dir: PathBuf,

533+ project_dir: PathBuf,

534+ clients: ClientStreams,

535+ latest_status: SharedStatus,

510536 output_monitor: Arc<vm::OutputMonitor>,

511537 vm_output_fd: std::os::unix::io::OwnedFd,

512538 vm_input_fd: std::os::unix::io::OwnedFd,

513539) -> vm::IoContext {

514− let log_path = instance_dir.join(VM_ROOT_LOG_NAME);

540+ let log_path = project_dir.join(INSTANCE_DIR_NAME).join(VM_ROOT_LOG_NAME);

515541 let log_file = fs::OpenOptions::new()

516542 .create(true)

517543 .write(true)

@@ -520,7 +546,6 @@ fn spawn_manager_io(

520546 .ok()

521547 .map(|file| Arc::new(Mutex::new(file)));

522548

523− let instance_path = instance_dir.join(INSTANCE_FILENAME);

524549 let config_for_output = config.clone();

525550 let log_for_output = log_file.clone();

526551 let mut line_buf = String::new();

@@ -543,6 +568,17 @@ fn spawn_manager_io(

543568 line_buf.drain(..=pos);

544569

545570 let cleaned = line.trim_start_matches(['\r', ' ']);

571+ if let Some(script_failure) = cleaned.strip_prefix("VIBEBOX_SCRIPT_ERROR:") {

572+ let failure = script_failure.trim();

573+ if !failure.is_empty() {

574+ tracing::error!(script_failure = %failure, "[vm] script reported failure");

575+ broadcast_status(

576+ &clients,

577+ &latest_status,

578+ &format!("{STATUS_VM_ERROR_PREFIX} {failure}"),

579+ );

580+ }

581+ }

546582 if let Some(pos) = cleaned.find("VIBEBOX_IPV4=") {

547583 let ip_raw = &cleaned[(pos + "VIBEBOX_IPV4=".len())..];

548584 let ip = extract_ipv4(ip_raw).unwrap_or_default();

@@ -551,7 +587,7 @@ fn spawn_manager_io(

551587 && cfg.vm_ipv4.as_deref() != Some(ip.as_str())

552588 {

553589 cfg.vm_ipv4 = Some(ip.clone());

554− let _ = write_instance_config(&instance_path, &cfg);

590+ let _ = write_instance_config(&project_dir, &cfg);

555591 }

556592 }

557593 }

@@ -574,12 +610,12 @@ enum ManagerEvent {

574610}

575611

576612struct ManagerOptions {

577− ensure_signed: bool,

578613 detach: bool,

579614 prepare_vm: bool,

580615}

581616

582617trait VmExecutor {

618+ #[allow(clippy::too_many_arguments)]

583619 fn run_vm(

584620 &self,

585621 args: vm::VmArg,

@@ -587,8 +623,10 @@ trait VmExecutor {

587623 extra_shares: Vec<DirectoryShare>,

588624 config: Arc<Mutex<InstanceConfig>>,

589625 instance_dir: PathBuf,

626+ clients: ClientStreams,

627+ latest_status: SharedStatus,

590628 vm_input_tx: Arc<Mutex<Option<mpsc::Sender<VmInput>>>>,

591− ) -> Result<(), Box<dyn std::error::Error>>;

629+ ) -> Result<()>;

592630}

593631

594632#[cfg_attr(feature = "mock-vm", allow(dead_code))]

@@ -601,15 +639,22 @@ impl VmExecutor for RealVmExecutor {

601639 extra_login_actions: Vec<LoginAction>,

602640 extra_shares: Vec<DirectoryShare>,

603641 config: Arc<Mutex<InstanceConfig>>,

604− instance_dir: PathBuf,

642+ project_dir: PathBuf,

643+ clients: ClientStreams,

644+ latest_status: SharedStatus,

605645 vm_input_tx: Arc<Mutex<Option<mpsc::Sender<VmInput>>>>,

606− ) -> Result<(), Box<dyn std::error::Error>> {

646+ ) -> Result<()> {

647+ let status_callback = |status: &str| {

648+ broadcast_status(&clients, &latest_status, status);

649+ };

607650 vm::run_with_args_and_extras(

608651 args,

609652 |output_monitor, vm_output_fd, vm_input_fd| {

610653 let io_ctx = spawn_manager_io(

611654 config.clone(),

612− instance_dir.clone(),

655+ project_dir.clone(),

656+ clients.clone(),

657+ latest_status.clone(),

613658 output_monitor,

614659 vm_output_fd,

615660 vm_input_fd,

@@ -619,6 +664,7 @@ impl VmExecutor for RealVmExecutor {

619664 },

620665 extra_login_actions,

621666 extra_shares,

667+ Some(&status_callback),

622668 )

623669 }

624670}

@@ -635,8 +681,10 @@ impl VmExecutor for MockVmExecutor {

635681 _extra_shares: Vec<DirectoryShare>,

636682 _config: Arc<Mutex<InstanceConfig>>,

637683 _instance_dir: PathBuf,

684+ _clients: ClientStreams,

685+ _latest_status: SharedStatus,

638686 vm_input_tx: Arc<Mutex<Option<mpsc::Sender<VmInput>>>>,

639− ) -> Result<(), Box<dyn std::error::Error>> {

687+ ) -> Result<()> {

640688 let (tx, rx) = mpsc::channel::<VmInput>();

641689 *vm_input_tx.lock().unwrap() = Some(tx);

642690 tracing::info!("mock vm executor running");

@@ -662,24 +710,14 @@ fn run_manager_with(

662710 auto_shutdown_ms: u64,

663711 executor: &dyn VmExecutor,

664712 options: ManagerOptions,

665−) -> Result<(), Box<dyn std::error::Error>> {

666− if options.ensure_signed {

667− let _had_skip = env::var("VIBEBOX_SKIP_CODESIGN").ok();

668− unsafe {

669− env::remove_var("VIBEBOX_SKIP_CODESIGN");

670− }

671− vm::ensure_signed();

672− unsafe {

673− env::set_var("VIBEBOX_SKIP_CODESIGN", "1");

674− }

675− }

713+) -> Result<()> {

676714 if options.detach {

677715 detach_from_terminal();

678716 }

679717

680718 let project_name = project_root

681719 .file_name()

682− .ok_or("Project directory has no name")?

720+ .ok_or_else(|| anyhow!("Project directory has no name"))?

683721 .to_string_lossy()

684722 .into_owned();

685723 let instance_dir = ensure_instance_dir(project_root)?;

@@ -687,16 +725,16 @@ fn run_manager_with(

687725 let _ = ensure_ssh_keypair(&instance_dir)?;

688726 }

689727

690− let mut config = load_or_create_instance_config(&instance_dir)?;

728+ let mut config = load_or_create_instance_config(project_root)?;

691729 if config.vm_ipv4.is_some() {

692730 config.vm_ipv4 = None;

693− write_instance_config(&instance_dir.join(INSTANCE_FILENAME), &config)?;

731+ write_instance_config(project_root, &config)?;

694732 }

695733 let config = Arc::new(Mutex::new(config));

696734 let ssh_user = config

697735 .lock()

698− .map(|cfg| cfg.ssh_user_display())

699− .unwrap_or_else(|_| DEFAULT_SSH_USER.to_string());

736+ .map(|cfg| cfg.ssh_user.clone())

737+ .map_err(|_| anyhow!("failed to acquire ssh user display"))?;

700738 if !args.no_default_mounts {

701739 inject_project_mount(&mut args.mounts, project_root, &ssh_user, &project_name);

702740 }

@@ -704,11 +742,10 @@ fn run_manager_with(

704742

705743 let project_guest_dir = format!("{PROJECT_GUEST_BASE}/{project_name}");

706744 let ssh_guest_dir = format!("/root/{}", GLOBAL_DIR_NAME);

707− let extra_shares = vec![DirectoryShare::new(

708− instance_dir.clone(),

709− ssh_guest_dir.clone().into(),

710− true,

711− )?];

745+ let extra_shares = vec![

746+ DirectoryShare::new(instance_dir.clone(), ssh_guest_dir.clone().into(), true)

747+ .map_err(|err| anyhow!(err.to_string()))?,

748+ ];

712749 let extra_login_actions = build_ssh_login_actions(

713750 &config,

714751 &project_name,

@@ -731,17 +768,43 @@ fn run_manager_with(

731768 let _ = fs::set_permissions(&socket_path, fs::Permissions::from_mode(0o600));

732769 tracing::info!(path = %socket_path.display(), "vm manager socket bound");

733770

771+ let clients: ClientStreams = Arc::new(Mutex::new(Vec::new()));

772+ let latest_status: SharedStatus = Arc::new(Mutex::new(String::new()));

734773 let (event_tx, event_rx) = mpsc::channel::<ManagerEvent>();

735774 let event_tx_accept = event_tx.clone();

775+ let clients_accept = clients.clone();

776+ let latest_status_accept = latest_status.clone();

736777 thread::spawn(move || {

737778 for stream in listener.incoming() {

738779 match stream {

739780 Ok(stream) => {

781+ let mut client_fd: Option<std::os::fd::RawFd> = None;

782+ let latest_status_snapshot = latest_status_accept

783+ .lock()

784+ .ok()

785+ .map(|status| status.clone());

786+ if let Ok(writer) = stream.try_clone() {

787+ let writer_fd = writer.as_raw_fd();

788+ if let Ok(mut connected) = clients_accept.lock() {

789+ connected.push(writer);

790+ client_fd = Some(writer_fd);

791+ if let Some(last) = connected.last_mut()

792+ && let Some(status) = latest_status_snapshot.as_deref()

793+ && !status.is_empty()

794+ {

795+ let _ = send_status_line(last, status);

796+ }

797+ }

798+ }

740799 let event_tx_conn = event_tx_accept.clone();

800+ let clients_conn = clients_accept.clone();

741801 thread::spawn(move || {

742802 let pid = read_client_pid(&stream);

743803 let _ = event_tx_conn.send(ManagerEvent::Inc(pid));

744804 wait_for_disconnect(stream);

805+ if let Some(fd) = client_fd {

806+ remove_client(&clients_conn, fd);

807+ }

745808 let _ = event_tx_conn.send(ManagerEvent::Dec(pid));

746809 });

747810 }

@@ -761,38 +824,43 @@ fn run_manager_with(

761824 extra_login_actions,

762825 extra_shares,

763826 config.clone(),

764− instance_dir.clone(),

827+ project_root.to_path_buf(),

828+ clients.clone(),

829+ latest_status.clone(),

765830 vm_input_tx.clone(),

766831 );

767832 tracing::info!("vm manager vm run completed");

768833 let vm_err = vm_result.err().map(|e| e.to_string());

769834 if let Some(err) = &vm_err {

770− let status_path = instance_dir.join(STATUS_FILE_NAME);

771− let _ = fs::write(&status_path, format!("error: {err}"));

835+ broadcast_status(

836+ &clients,

837+ &latest_status,

838+ &format!("{STATUS_VM_ERROR_PREFIX} {err}"),

839+ );

772840 }

773841 let _ = event_tx.send(ManagerEvent::VmExited(vm_err.clone()));

774− let event_loop_result: Result<(), String> = event_loop_handle

842+ let event_loop_result = event_loop_handle

775843 .join()

776− .unwrap_or_else(|_| Err("vm manager event loop panicked".into()))

844+ .unwrap_or_else(|_| Err(Error::msg("vm manager event loop panicked")))

777845 .map_err(|err| err.to_string());

778846 let _ = fs::remove_file(&socket_path);

779847 if let Err(err) = &event_loop_result {

780848 tracing::error!(error = %err, "vm manager exiting due to event loop error");

781− return Err(err.to_string().into());

849+ bail!(err.to_string());

782850 }

783851 if let Some(err) = vm_err {

784852 tracing::error!(error = %err, "vm manager exiting due to vm error");

785− return Err(err.into());

853+ bail!(err);

786854 }

787855 tracing::info!("vm manager exiting");

788− Ok(event_loop_result?)

856+ event_loop_result.map_err(Error::msg)

789857}

790858

791859fn manager_event_loop(

792860 event_rx: mpsc::Receiver<ManagerEvent>,

793861 vm_input_tx: Arc<Mutex<Option<mpsc::Sender<VmInput>>>>,

794862 auto_shutdown_ms: u64,

795−) -> Result<(), String> {

863+) -> Result<()> {

796864 let mut ref_count: usize = 0;

797865 let mut shutdown_deadline: Option<Instant> = None;

798866 let mut shutdown_sent = false;

@@ -902,7 +970,7 @@ fn manager_event_loop(

902970#[cfg(test)]

903971mod tests {

904972 use super::*;

905− use std::{sync::mpsc, thread, time::Duration};

973+ use std::{fs, sync::mpsc, thread, time::Duration};

906974

907975 #[test]

908976 fn manager_powers_off_after_grace_when_no_refs() {

@@ -984,4 +1052,26 @@ mod tests {

9841052 let _ = event_tx.send(ManagerEvent::VmExited(None));

9851053 let _ = manager_thread.join();

9861054 }

1055+

1056+ #[test]

1057+ fn lock_is_not_stale_when_owner_pid_is_alive() {

1058+ let temp = tempfile::Builder::new()

1059+ .prefix("vb")

1060+ .tempdir_in("/tmp")

1061+ .expect("tempdir");

1062+ let lock_path = temp.path().join("vm.lock");

1063+ fs::write(&lock_path, format!("pid={}\n", std::process::id())).expect("write lock");

1064+ assert!(!is_lock_stale(&lock_path));

1065+ }

1066+

1067+ #[test]

1068+ fn lock_is_stale_when_owner_pid_is_missing() {

1069+ let temp = tempfile::Builder::new()

1070+ .prefix("vb")

1071+ .tempdir_in("/tmp")

1072+ .expect("tempdir");

1073+ let lock_path = temp.path().join("vm.lock");

1074+ fs::write(&lock_path, "pid=999999\n").expect("write lock");

1075+ assert!(is_lock_stale(&lock_path));

1076+ }

9871077}