main..8669deb · vibebox

git.iko.soy/vibebox

16 files changed+799−1366

unifiedsplit

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

Cargo.lock+1−18

@@ -82,12 +82,6 @@ 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−

9185[[package]]

9286name = "assert_cmd"

9387version = "2.1.2"

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

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

151145checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"

152146

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−

162147[[package]]

163148name = "cassowary"

164149version = "0.3.0"

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

13181303

13191304[[package]]

13201305name = "vibebox"

1321−version = "0.3.2"

1306+version = "0.2.5"

13221307dependencies = [

1323− "anyhow",

13241308 "assert_cmd",

13251309 "block2",

1326− "bytesize",

13271310 "clap",

13281311 "color-eyre",

13291312 "crossterm",

Cargo.toml+1−3

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

11[package]

22name = "vibebox"

3−version = "0.3.2"

3+version = "0.2.5"

44edition = "2024"

55authors = ["Finn Sheng"]

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

@@ -42,8 +42,6 @@ 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"

4745

4846[dev-dependencies]

4947assert_cmd = "2"

docs/tasks.md+10−14

@@ -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. [x] Run tests and validate coverage for the new module.

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

2929

3030## TUI

3131

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

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. [x] intensive integration test.

52+11. [ ] intensive integration test.

5353

5454## Publish

5555

56−1. [x] write the docs.

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

58−3. [x] setup website.

56+1. [ ] write the docs.

57+2. [ ] setup quick install link.

58+3. [ ] setup website.

5959

6060## Stage 2

6161

62621. [ ] retouch the cli ux.

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

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.

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

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

2121 color_eyre::install()?;

2222

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

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)

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)

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

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);

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

3029 let args = vm::VmArg {

3130 cpu_count: config.box_cfg.cpu_count,

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

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

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),

3433 no_default_mounts: false,

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

3635 };

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

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

3938

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

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

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

4241 if let Err(err) = result {

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

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

src/bin/vibebox.rs+95−53

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

1−use bytesize::ByteSize;

2−use clap::Parser;

3−use color_eyre::Result;

4−use dialoguer::Confirm;

51use std::{

62 env,

73 ffi::OsString,

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

106 path::{Path, PathBuf},

117 sync::{Arc, Mutex},

128};

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,9 +17,8 @@ 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;

2120use vibebox::{

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

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

2322};

2423

2524#[derive(Debug, Parser)]

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

5756

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

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

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

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

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

6260

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;

6389 let vm_info = VmInfo {

64− max_memory: config.box_cfg.ram_size,

65− cpu_cores: config.box_cfg.cpu_count,

66− max_disk: config.box_cfg.disk_size,

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,

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

68− auto_shutdown_ms: config.supervisor.auto_shutdown_ms,

94+ auto_shutdown_ms,

6995 };

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

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

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

7399 }

74100 } else {

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

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

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

77102 }

78103 let commands = commands::build_commands();

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

105+

80106 {

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

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

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

86112 writeln!(stdout)?;

87113 stdout.flush()?;

88114 }

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

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

90116 if let Some(handle) = stderr_handle {

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

92118 }

93119

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| {

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| {

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

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

103131 })?;

104132

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−

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

124134

125135 Ok(())

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

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

202212 file_count,

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

204− ByteSize(total_bytes),

214+ format_bytes(total_bytes),

205215 cache_dir.display()

206216 );

207217 Ok(())

208218 }

209219 Command::Explain => {

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

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

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

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

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

214223 let networks = explain::build_network_rows(cwd)

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

231240 .to_string()

232241}

233242

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+

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

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

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

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

279302 Ok((file_count, total_bytes))

280303}

281304

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+

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

283323 let Some(raw) = value else {

284324 return "-".to_string();

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

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

321361}

322362

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

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

324364 let instance_raw = cwd

325365 .join(session_manager::INSTANCE_DIR_NAME)

326366 .join("instance.raw");

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

328368 return;

329369 };

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

331− if current_size == configured_size {

370+ let current_bytes = meta.len();

371+ if current_bytes == configured_bytes {

332372 return;

333373 }

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);

334376 tracing::warn!(

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

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

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

337− current_size,

338− configured_size,

379+ current_gb,

380+ target_gb

339381 );

340382}

341383

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

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

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

346388 let file_filter = filter.clone();

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

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

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

349391 let file = instance::ensure_instance_dir(cwd)

350392 .ok()

351393 .and_then(|instance_dir| {

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

353− fs::OpenOptions::new()

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

354396 .create(true)

355397 .write(true)

356398 .truncate(true)

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

364406 .with_target(false)

365407 .with_ansi(ansi)

366408 .without_time()

367− .with_writer(io::stderr)

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

368410 .with_filter(stderr_filter);

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

370412 if let Some(file) = file {

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

382424 let stderr_layer = fmt::layer()

383425 .with_target(false)

384426 .with_ansi(ansi)

385− .with_writer(io::stderr)

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

386428 .with_filter(filter);

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

388430 if let Some(file) = file {

src/config.rs+77−467

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

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

2−use bytesize::ByteSize;

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

41use std::{

52 env, fs, io,

63 path::{Path, PathBuf},

74};

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

98use crate::vm::DirectoryShare;

109

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

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

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

1312

1413const DEFAULT_CPU_COUNT: usize = 2;

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

2322 pub supervisor: SupervisorConfig,

2423}

2524

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−

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

8826pub struct BoxConfig {

8927 pub cpu_count: usize,

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,

28+ pub ram_mb: u64,

29+ pub disk_gb: u64,

9430 pub mounts: Vec<String>,

9531}

9632

9733impl Default for BoxConfig {

9834 fn default() -> Self {

9935 Self {

100− cpu_count: DEFAULT_CPU_COUNT,

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

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

36+ cpu_count: default_cpu_count(),

37+ ram_mb: default_ram_mb(),

38+ disk_gb: default_disk_gb(),

10339 mounts: default_mounts(),

10440 }

10541 }

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

11349impl Default for SupervisorConfig {

11450 fn default() -> Self {

11551 Self {

116− auto_shutdown_ms: DEFAULT_AUTO_SHUTDOWN_MS,

52+ auto_shutdown_ms: default_auto_shutdown_ms(),

11753 }

11854 }

11955}

12056

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+

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

12270 vec![

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

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

12573 ]

12674}

12775

76+fn default_disk_gb() -> u64 {

77+ DEFAULT_DISK_GB

78+}

79+

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

12981 project_root.join(CONFIG_FILENAME)

13082}

13183

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)?;

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);

13489 if !path.exists() {

13590 let default_config = Config::default();

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

@@ -140,24 +95,32 @@ pub fn ensure_config_file(project_root: &Path, override_path: Option<&Path>) ->

14095 Ok(path)

14196}

14297

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

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

14499 load_config_with_path(project_root, None)

145100}

146101

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")?;

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+ };

151111 let trimmed = raw.trim();

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

153113 if trimmed.is_empty() {

154− bail!(format!(

114+ die(&format!(

155115 "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)",

156116 path.display()

157117 ));

158118 }

159119

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

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

121+ Ok(value) => value,

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

123+ };

161124 let schema_errors = validate_schema(&value);

162125 if !schema_errors.is_empty() {

163126 let message = format!(

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

165128 path.display(),

166129 schema_errors.join("\n- ")

167130 );

168− bail!(message);

131+ die(&message);

169132 }

170133

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

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

173− Ok(config)

174−}

175−

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)

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

179140}

180141

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")?;

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+ };

187147

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

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

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 {

190152 if path.is_absolute() {

191153 path

192154 } else {

@@ -197,50 +159,14 @@ fn resolve_config_path_inner(

197159 };

198160

199161 let normalized = normalize_path(&raw_path);

200− let resolved =

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

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

203− bail!(

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

163+ die(&format!(

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

205165 root.display(),

206− resolved.display()

207− );

208− }

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− })?;

166+ normalized.display()

167+ ));

241168 }

242− missing.reverse();

243− Ok((current, missing))

169+ normalized

244170}

245171

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

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

337263 }

338264}

339265

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

266+fn validate_or_exit(config: &Config) {

341267 if config.box_cfg.cpu_count == 0 {

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

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

343269 }

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

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

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

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

346272 }

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

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

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

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

349275 }

350276 if config.supervisor.auto_shutdown_ms == 0 {

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

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

352278 }

353279 for spec in &config.box_cfg.mounts {

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

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

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

356282 }

357283 }

358− Ok(())

359284}

360285

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− }

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

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

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

679289}

src/error_report.shdeleted−28

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

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+47−32

@@ -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};

51use std::{

62 env,

3+ error::Error,

74 path::{Path, PathBuf},

85};

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

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

9+pub fn build_mount_rows(

10+ cwd: &Path,

11+ config: &config::Config,

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

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

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

13− let guest_home = resolve_guest_home(project);

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

15+ let guest_home = resolve_guest_home(cwd)?;

1416 for spec in &config.box_cfg.mounts {

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

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

1618 }

1719 Ok(rows)

1820}

1921

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

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);

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

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− }

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

28+ vm_ip = ip;

2929 }

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

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

@@ -41,13 +41,13 @@ pub fn build_network_rows(project_dir: &Path) -> Result<Vec<tui::NetworkListRow>

4141 Ok(vec![row])

4242}

4343

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

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

4545 let project_name = cwd

4646 .file_name()

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

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

48+ .unwrap_or("project");

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

50− let project_host = relative_to_home(cwd);

50+ let project_host = display_path(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>> {

5757

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

5959 .map(PathBuf::from)

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

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

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: relative_to_home(&guest_mise_cache),

67+ host: display_path(&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> {

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

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

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

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

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

8484 }

8585 let host_part = parts[0];

8686 let guest_part = parts[1];

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

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

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

9191 other => {

92− bail![format!(

92+ return Err(format!(

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

9494 other

95− )];

95+ )

96+ .into());

9697 }

9798 }

9899 } else {

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

115116 }

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

117118 if host_path.is_absolute() {

118− return relative_to_home(&host_path);

119+ return display_path(&host_path);

119120 }

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

121122 if candidate.is_absolute() {

122− relative_to_home(&candidate)

123+ display_path(&candidate)

123124 } else {

124125 host.to_string()

125126 }

126127}

127128

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),

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}"));

133133 }

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

134135}

135136

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

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

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

155156 }

156157}

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+154−289

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

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

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

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

41use std::{

52 env, fs,

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

3+ io::{self},

74 net::{SocketAddr, TcpStream},

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

96 path::{Path, PathBuf},

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

11− sync::{

12− Arc, Mutex,

13− atomic::{AtomicBool, Ordering},

14− mpsc,

15− },

7+ process::{Command, Stdio},

8+ sync::{Arc, Mutex},

169 thread,

1710 time::{Duration, Instant},

1811};

12+

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

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

2015use uuid::Uuid;

2116

2217use crate::{

2318 commands,

24− session_manager::INSTANCE_DIR_NAME,

25− session_manager::{VM_MANAGER_PID_NAME, VM_MANAGER_SOCKET_NAME},

19+ session_manager::{INSTANCE_DIR_NAME, INSTANCE_FILENAME},

2620 vm::{self, LoginAction},

2721};

2822

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

30−

3123const SSH_KEY_NAME: &str = "ssh_key";

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

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

34−const SSH_CONNECT_RETRIES: usize = 10;

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;

3529const SSH_CONNECT_DELAY_MS: u64 = 500;

3630const 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−}

9231

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

94−pub struct InstanceConfig {

33+pub(crate) struct InstanceConfig {

9534 #[serde(default)]

96− pub id: String,

35+ id: String,

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

98− pub ssh_user: String,

37+ ssh_user: String,

9938 #[serde(default)]

10039 sudo_password: String,

10140 #[serde(default)]

102− pub last_active: Option<String>,

41+ last_active: Option<String>,

10342 #[serde(default)]

104− pub vm_ipv4: Option<String>,

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

10544}

10645

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,

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()

11552 }

11653 }

11754}

11855

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

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>> {

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

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

12263 let instance_dir = ensure_instance_dir(&project_root)?;

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

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

12566

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

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

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

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

12970

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

71+ let _manager_conn = manager_conn;

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

13173

132− let ip = load_or_create_instance_config(&project_root)?

74+ let ip = load_or_create_instance_config(&instance_dir)?

13375 .vm_ipv4

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

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

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

13678

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

79+ run_ssh_session(ssh_key, ssh_user, ip)

13880}

13981

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

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

14385 Ok(instance_dir)

14486}

14587

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

88+pub(crate) fn ensure_ssh_keypair(

89+ instance_dir: &Path,

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

14791 let private_key = instance_dir.join(SSH_KEY_NAME);

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

14993

@@ -165,9 +109,7 @@ pub fn ensure_ssh_keypair(instance_dir: &Path) -> Result<(PathBuf, PathBuf)> {

165109 "-N",

166110 "",

167111 "-f",

168− private_key

169− .to_str()

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

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

171113 "-C",

172114 "vibebox",

173115 ])

@@ -177,7 +119,7 @@ pub fn ensure_ssh_keypair(instance_dir: &Path) -> Result<(PathBuf, PathBuf)> {

177119 .status()?;

178120

179121 if !status.success() {

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

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

181123 }

182124

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

@@ -186,66 +128,98 @@ pub fn ensure_ssh_keypair(instance_dir: &Path) -> Result<(PathBuf, PathBuf)> {

186128 Ok((private_key, public_key))

187129}

188130

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− });

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+ };

195147

196148 let mut changed = false;

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

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

150+ config.ssh_user = default_ssh_user();

199151 changed = true;

200152 }

201153

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

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

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

204156 changed = true;

205157 }

206158

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

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

160+ config.sudo_password = generate_password();

209161 changed = true;

210162 }

211163

212− if !exist || changed {

213− write_instance_config(project_dir, &config)?;

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

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

214166 }

215167

216168 Ok(config)

217169}

218170

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);

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);

222175 if !config_path.exists() {

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

176+ return Ok(None);

224177 }

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

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

227− Ok(config)

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))

228188}

229189

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

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

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()))

197+}

198+

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)?;

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

233202 config.last_active = Some(now);

234− write_instance_config(project_dir, &config)?;

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

235204 Ok(())

236205}

237206

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

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

207+pub(crate) fn write_instance_config(

208+ path: &Path,

209+ config: &InstanceConfig,

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

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

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))?;

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

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

244214 Ok(())

245215}

246216

217+fn generate_password() -> String {

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

219+}

220+

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

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

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

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

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

251225

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

264238 best

265239}

266240

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−

285241fn wait_for_vm_ipv4(

286− project_dir: &Path,

242+ instance_dir: &Path,

287243 timeout: Duration,

288− manager_conn: &UnixStream,

289−) -> Result<()> {

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

290245 let start = Instant::now();

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

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();

247+ let mut next_status_check = start;

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

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

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

251+ let mut status_missing = true;

298252 let mut once_hint = false;

299253 loop {

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)?;

254+ let config = load_or_create_instance_config(instance_dir)?;

321255 if config.vm_ipv4.is_some() {

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

322257 return Ok(());

323258 }

324259 if start.elapsed() > timeout {

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

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

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

326262 }

327−

328263 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+ }

329286 if now >= next_log_at {

330287 let waited = start.elapsed();

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

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

334291 );

335292 once_hint = true;

336293 }

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

294+ if status_missing {

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

296+ }

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

339298 }

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

340300 }

341301}

342302

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

344304 ssh_key: PathBuf,

345305 ssh_user: String,

346306 ip: String,

347− manager_conn: UnixStream,

348− project_root: PathBuf,

349−) -> Result<()> {

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

350308 let mut attempts = 0usize;

351309 loop {

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

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

354− }

355310 attempts += 1;

356311 if !ssh_port_open(&ip) {

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

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

363318 SSH_CONNECT_RETRIES

364319 );

365320 if attempts >= SSH_CONNECT_RETRIES {

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

321+ return Err(

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

323+ );

367324 }

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

369326 continue;

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

377334 attempts,

378335 SSH_CONNECT_RETRIES

379336 );

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

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

381338 .args([

382339 "-i",

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

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

384341 "-o",

385342 "IdentitiesOnly=yes",

386343 "-o",

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

405362 .stdin(Stdio::inherit())

406363 .stdout(Stdio::inherit())

407364 .stderr(Stdio::inherit())

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− };

365+ .status();

450366

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;

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());

462376 }

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

378+ }

379+ Ok(status) => {

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

464381 break;

465382 }

466383 Err(err) => {

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

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

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

469386 }

470387 }

471388 }

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

473390 Ok(())

474391}

475392

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−

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

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

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

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

519412 Ok(addr) => addr,

520413 Err(_) => return false,

521414 };

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

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

523416}

524417

525−pub fn build_ssh_login_actions(

418+pub(crate) fn build_ssh_login_actions(

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

527420 project_name: &str,

528421 project_guest_dir: &str,

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

537430

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

539432

540− let ssh_script = SSH_SETUP_SCRIPT

433+ let setup_script = SSH_SETUP_SCRIPT

541434 .replace("__SSH_USER__", &ssh_user)

542435 .replace("__SUDO_PASSWORD__", &sudo_password)

543436 .replace("__PROJECT_NAME__", project_name)

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

545438 .replace("__KEY_PATH__", &key_path)

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

547440 .replace("__VIBEBOX_HOME_LINKS__", home_links_script);

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

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

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

550443

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

552445}

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,4 +8,3 @@ pub mod vm_manager;

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

1010pub mod config;

11−pub mod utils;

src/session_manager.rs+93−56

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

1−use anyhow::Result;

21use std::{

32 env, fs,

43 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};

108use serde::{Deserialize, Serialize};

119

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−const SESSION_TOML_SUFFIX: &str = ".toml";

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

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

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

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

1819const SESSIONS_DIR_NAME: &str = "sessions";

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

3132 pub id: String,

3233}

3334

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+

3443#[derive(Debug)]

3544pub struct SessionManager {

3645 sessions_dir: PathBuf,

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

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

5362 MissingDirectory(PathBuf),

5463 #[error(transparent)]

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

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

5665 #[error(transparent)]

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

5867 #[error(transparent)]

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

8594 let mut added = false;

8695

8796 if has_config {

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

89− if let Some(id) = id {

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

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

9099 let record = SessionEntry {

91100 directory: directory.clone(),

92101 id: id.clone(),

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

101110 } else {

102111 tracing::warn!(

103112 directory = %directory.display(),

113+ file = INSTANCE_FILENAME,

104114 "missing session id in instance file"

105115 );

106116 }

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

138148 }

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

140150 for session in sessions {

141− let last_active =

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

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

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

144153 records.push(SessionRecord {

145154 directory: session.directory,

146155 id: session.id,

147− last_active,

156+ last_active: meta.last_active,

148157 active,

149158 });

150159 }

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

262271 if !directory.is_absolute() {

263272 return false;

264273 }

265− config_path(directory).is_file()

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

266275}

267276

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

269278 let instance_dir = directory.join(INSTANCE_DIR_NAME);

270279 let pid_path = instance_dir.join(VM_MANAGER_PID_NAME);

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,

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,

281311 }

282312}

283313

@@ -285,11 +315,31 @@ fn read_session_file(path: &Path) -> Result<SessionEntry, SessionError> {

285315 let raw = fs::read_to_string(path)?;

286316 let record: SessionEntry = toml::from_str(&raw)?;

287317 if record.id.trim().is_empty() {

288− return Err(io::Error::new(io::ErrorKind::InvalidData, "session id missing").into());

318+ return Err(std::io::Error::new(io::ErrorKind::InvalidData, "session id missing").into());

289319 }

290320 Ok(record)

291321}

292322

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+

293343fn atomic_write(path: &Path, content: &[u8]) -> io::Result<()> {

294344 let Some(parent) = path.parent() else {

295345 return Err(io::Error::new(

@@ -312,7 +362,6 @@ fn atomic_write(path: &Path, content: &[u8]) -> io::Result<()> {

312362#[cfg(test)]

313363mod tests {

314364 use super::*;

315− use crate::instance::{InstanceConfig, write_instance_config};

316365 use std::fs;

317366 use tempfile::TempDir;

318367

@@ -326,14 +375,11 @@ mod tests {

326375 dir

327376 }

328377

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)

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();

337383 }

338384

339385 #[test]

@@ -341,14 +387,11 @@ mod tests {

341387 let temp = TempDir::new().unwrap();

342388 let mgr = manager(&temp);

343389 let project_dir = create_project_dir(&temp);

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()

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",

352395 );

353396

354397 let dirs = mgr.update_global_sessions(&project_dir).unwrap();

@@ -369,18 +412,15 @@ mod tests {

369412 let temp = TempDir::new().unwrap();

370413 let mgr = manager(&temp);

371414 let project_dir = create_project_dir(&temp);

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()

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",

380420 );

381421 let _ = mgr.update_global_sessions(&project_dir).unwrap();

382422

383− fs::remove_file(config_path(project_dir.as_path())).unwrap();

423+ fs::remove_file(project_dir.join(CONFIG_FILENAME)).unwrap();

384424 let sessions = mgr.list_sessions().unwrap();

385425 assert!(sessions.is_empty());

386426

@@ -411,14 +451,11 @@ mod tests {

411451 let temp = TempDir::new().unwrap();

412452 let mgr = manager(&temp);

413453 let project_dir = create_project_dir(&temp);

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()

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",

422459 );

423460 let _ = mgr.update_global_sessions(&project_dir).unwrap();

424461

src/ssh.sh+10−18

@@ -2,7 +2,6 @@

22set -eu

44SSH_USER="__SSH_USER__"

5−SUDO_PASSWORD="__SUDO_PASSWORD__"

65PROJECT_NAME="__PROJECT_NAME__"

76PROJECT_GUEST_DIR="__PROJECT_GUEST_DIR__"

87KEY_PATH="__KEY_PATH__"

@@ -62,10 +61,6 @@ if ! id -u "$SSH_USER" >/dev/null 2>&1; then

6261 usermod -aG sudo "$SSH_USER" || true

6362fi

6463

65−if [ -n "$SUDO_PASSWORD" ]; then

66− echo "${SSH_USER}:${SUDO_PASSWORD}" | chpasswd

67−fi

68−

6964install -d -m 700 -o "$SSH_USER" -g "$SSH_USER" "/home/${SSH_USER}/.ssh"

7065install -m 600 -o "$SSH_USER" -g "$SSH_USER" "$KEY_PATH" "/home/${SSH_USER}/.ssh/authorized_keys"

7166

@@ -114,8 +109,8 @@ mise_ok() { command -v mise >/dev/null 2>&1 || [ -x "$MISE_BIN" ]; }

114109mise_install() {

115110 if [ ! -x "$MISE_BIN" ] && ! command -v mise >/dev/null 2>&1; then

116111 if ! curl https://mise.run | HOME="$USER_HOME" sh; then

117− mise_warn "mise install script failed"

118− return 1

112+ mise_warn "mise install script failed (continuing)"

113+ return 0

119114 fi

120115 fi

121116 echo 'eval "$(~/.local/bin/mise activate bash)"' >> "${USER_HOME}/.bashrc"

@@ -141,21 +136,18 @@ MISE

141136 touch "${USER_HOME}/.config/mise/mise.lock"

142137 if [ -x "$MISE_BIN" ]; then

143138 if ! HOME="$USER_HOME" "$MISE_BIN" install; then

144− mise_warn "mise install failed"

145− return 1

139+ mise_warn "mise install failed (continuing)"

140+ return 0

146141 fi

147142 else

148143 if ! HOME="$USER_HOME" mise install; then

149− mise_warn "mise install failed"

150− return 1

144+ mise_warn "mise install failed (continuing)"

145+ return 0

151146 fi

152147 fi

153148}

154149

155−if ! mise_install; then

156− diag "mise installation failed"

157− vibebox_fail "mise installation failed" 1

158−fi

150+mise_install || true

159151

160152# 3) start ssh (don't swallow failures)

161153# If ssh is already active, don't force start/restart.

@@ -163,7 +155,7 @@ if ! systemctl is-active --quiet ssh; then

163155 if ! systemctl start ssh; then

164156 diag "systemctl start ssh failed"

165157 dump_diag

166− vibebox_fail "failed to start ssh service" 1

158+ exit 1

167159 fi

168160fi

169161

@@ -201,7 +193,7 @@ done

201193if [ -z "$dev" ] || [ -z "$ip" ]; then

202194 diag "no stable IPv4 on default route interface"

203195 dump_diag

204− vibebox_fail "no stable ipv4 route on default interface" 1

196+ exit 1

205197fi

206198

207199# 5) strong verify: ssh must listen externally (0.0.0.0:22 or $ip:22 or [::]:22)

@@ -220,7 +212,7 @@ done

220212if ! listens_ok; then

221213 diag "sshd not listening on 0.0.0.0:22 / ${ip}:22"

222214 dump_diag

223− vibebox_fail "sshd is not listening on the expected address" 1

215+ exit 1

224216fi

225217

226218ip a

src/tui.rs+31−31

@@ -1,4 +1,10 @@

1−use bytesize::ByteSize;

1+use std::{

2+ io::{self, Write},

3+ os::unix::io::OwnedFd,

4+ path::PathBuf,

5+ sync::{Arc, Mutex},

6+};

28use color_eyre::Result;

39use crossterm::{

410 cursor::{MoveTo, Show},

@@ -16,12 +22,6 @@ use ratatui::{

1622 text::{Line, Span, Text},

1723 widgets::{Block, Borders, Cell, List, ListItem, Paragraph, Row, Table, Widget},

1824};

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: ByteSize,

42+ pub max_memory_mb: u64,

4343 pub cpu_cores: usize,

44− pub max_disk: ByteSize,

44+ pub max_disk_gb: f32,

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: Color) -> CrosstermColor {

477+fn map_color(color: ratatui::style::Color) -> CrosstermColor {

478478 match color {

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),

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),

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 / {} / {}",

578− app.vm_info.cpu_cores, app.vm_info.max_memory, app.vm_info.max_disk

577+ "{} cores / {} MB / {} GB",

578+ app.vm_info.cpu_cores, app.vm_info.max_memory_mb, app.vm_info.max_disk_gb

579579 ),

580580 Style::default().fg(Color::Green),

581581 ),

src/utils.rsdeleted−18

@@ -1,18 +0,0 @@

1−use std::{

2− env,

3− path::{Path, PathBuf},

4−};

5−

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+159−126

@@ -1,5 +1,5 @@

1+use crate::instance::STATUS_FILE_NAME;

12use 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,7 +23,6 @@ use std::{

2323};

2424

2525use block2::RcBlock;

26−use bytesize::ByteSize;

2726use dispatch2::DispatchQueue;

2827use objc2::{AnyThread, rc::Retained, runtime::ProtocolObject};

2928use objc2_foundation::*;

@@ -35,19 +34,49 @@ const DEBIAN_COMPRESSED_SIZE_BYTES: u64 = 280901576;

3534const SHARED_DIRECTORIES_TAG: &str = "shared";

3635pub const PROJECT_GUEST_BASE: &str = "/usr/local/vibebox-mounts";

3736

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;

3841const START_TIMEOUT: Duration = Duration::from_secs(60);

3942const LOGIN_EXPECT_TIMEOUT: Duration = Duration::from_secs(120);

4043const PROVISION_EXPECT_TIMEOUT: Duration = Duration::from_secs(900);

4144

42−const ERROR_REPORT_SCRIPT: &str = include_str!("error_report.sh");

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+}

4371const PROVISION_SCRIPT: &str = include_str!("provision.sh");

72+const PROVISION_SCRIPT_NAME: &str = "provision.sh";

4473const RESIZE_DISK_SCRIPT: &str = include_str!("resize_disk.sh");

4574const DEFAULT_RAW_NAME: &str = "default.raw";

4675const INSTANCE_RAW_NAME: &str = "instance.raw";

4776const BASE_DISK_RAW_NAME: &str = "disk.raw";

4877

4978#[derive(Clone)]

50−pub enum LoginAction {

79+pub(crate) enum LoginAction {

5180 Expect {

5281 text: String,

5382 timeout: Duration,

@@ -59,20 +88,23 @@ pub enum LoginAction {

5988 },

6089 Send(String),

6190}

62−use crate::config::BoxConfig;

6391use LoginAction::*;

6492

6593#[derive(Clone)]

66−pub struct DirectoryShare {

94+pub(crate) struct DirectoryShare {

6795 host: PathBuf,

6896 guest: PathBuf,

6997 read_only: bool,

7098}

7199

72100impl DirectoryShare {

73− pub fn new(host: PathBuf, mut guest: PathBuf, read_only: bool) -> Result<Self> {

101+ pub(crate) fn new(

102+ host: PathBuf,

103+ mut guest: PathBuf,

104+ read_only: bool,

105+ ) -> Result<Self, Box<dyn std::error::Error>> {

74106 if !host.exists() {

75− bail!(format!("host path does not exist: {}", host.display()));

107+ return Err(format!("Host path does not exist: {}", host.display()).into());

76108 }

77109 if !guest.is_absolute() {

78110 guest = PathBuf::from("/root").join(guest);

@@ -84,10 +116,10 @@ impl DirectoryShare {

84116 })

85117 }

86118

87− pub fn from_mount_spec(spec: &str) -> Result<Self> {

119+ pub(crate) fn from_mount_spec(spec: &str) -> Result<Self, Box<dyn std::error::Error>> {

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

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

90− bail!(format!("invalid mount spec: {spec}"));

122+ return Err(format!("Invalid mount spec: {spec}").into());

91123 }

92124 let host = expand_tilde_path(parts[0]);

93125 let guest = PathBuf::from(parts[1]);

@@ -96,10 +128,11 @@ impl DirectoryShare {

96128 "read-only" => true,

97129 "read-write" => false,

98130 _ => {

99− bail!(format!(

131+ return Err(format!(

100132 "Invalid mount mode '{}'; expected read-only or read-write",

101133 parts[2]

102− ));

134+ )

135+ .into());

103136 }

104137 }

105138 } else {

@@ -143,28 +176,19 @@ pub struct VmArg {

143176 pub mounts: Vec<String>,

144177}

145178

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<()>

179+pub fn run_with_args<F>(args: VmArg, io_handler: F) -> Result<(), Box<dyn std::error::Error>>

155180where

156181 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,

157182{

158− run_with_args_and_extras(args, io_handler, Vec::new(), Vec::new(), None)

183+ run_with_args_and_extras(args, io_handler, Vec::new(), Vec::new())

159184}

160185

161−pub fn run_with_args_and_extras<F>(

186+pub(crate) fn run_with_args_and_extras<F>(

162187 args: VmArg,

163188 io_handler: F,

164189 extra_login_actions: Vec<LoginAction>,

165190 extra_directory_shares: Vec<DirectoryShare>,

166− status: Option<&StatusEmitter<'_>>,

167−) -> Result<()>

191+) -> Result<(), Box<dyn std::error::Error>>

168192where

169193 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,

170194{

@@ -173,7 +197,7 @@ where

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

174198 let project_name = project_root

175199 .file_name()

176− .with_context(|| "Project directory has no name")?

200+ .ok_or("Project directory has no name")?

177201 .to_string_lossy()

178202 .into_owned();

179203

@@ -186,8 +210,8 @@ where

186210

187211 let instance_dir = project_root.join(INSTANCE_DIR_NAME);

188212 fs::create_dir_all(&instance_dir)?;

189− emit_status(status, "preparing VM image...");

190− tracing::info!("preparing VM image...");

213+ let status_file = StatusFile::new(instance_dir.join(STATUS_FILE_NAME));

214+ status_file.update("preparing VM image...");

191215 let provision_log = instance_dir.join("provision.log");

192216

193217 let basename_compressed = DEBIAN_COMPRESSED_DISK_URL.rsplit('/').next().unwrap();

@@ -212,14 +236,14 @@ where

212236 &base_compressed,

213237 &default_raw,

214238 std::slice::from_ref(&mise_directory_share),

239+ Some(&status_file),

215240 Some(&provision_log),

216− status,

217241 )?;

218242 let _ = ensure_instance_disk(

219243 &instance_raw,

220244 &default_raw,

221− ByteSize(args.disk_bytes),

222− status,

245+ args.disk_bytes,

246+ Some(&status_file),

223247 )?;

224248 let base_size = fs::metadata(&default_raw)?.len();

225249 let instance_size = fs::metadata(&instance_raw)?.len();

@@ -249,7 +273,7 @@ where

249273 }

250274

251275 if needs_resize {

252− let resize_cmd = script_command_from_content("resize_disk.sh", RESIZE_DISK_SCRIPT)?;

276+ let resize_cmd = script_command_from_content("resize_disk", RESIZE_DISK_SCRIPT)?;

253277 login_actions.push(Send(resize_cmd));

254278 }

255279

@@ -265,29 +289,25 @@ where

265289 &directory_shares[..],

266290 args.cpu_count,

267291 args.ram_bytes,

268− status,

292+ Some(&status_file),

269293 io_handler,

270294 )

271295}

272296

273−pub fn script_command_from_content(label: &str, script: &str) -> Result<String> {

297+pub(crate) fn script_command_from_content(

298+ label: &str,

299+ script: &str,

300+) -> Result<String, Box<dyn std::error::Error>> {

274301 let marker = "VIBE_SCRIPT_EOF";

275302 let guest_dir = "/tmp/vibe-scripts";

276303 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);

284304 let command = format!(

285− "mkdir -p {guest_dir}\ncat >{guest_path} <<'{marker}'\n{wrapped_script}\n{marker}\nchmod +x {guest_path}\n{guest_path}"

305+ "mkdir -p {guest_dir}\ncat >{guest_path} <<'{marker}'\n{script}\n{marker}\nchmod +x {guest_path}\n{guest_path}"

286306 );

287307 if script.contains(marker) {

288− bail!(format!(

289− "Script '{label}' contains marker '{marker}', cannot safely upload"

290− ));

308+ return Err(

309+ format!("Script '{label}' contains marker '{marker}', cannot safely upload").into(),

310+ );

291311 }

292312 Ok(command)

293313}

@@ -484,16 +504,18 @@ impl IoControl {

484504fn ensure_base_image(

485505 base_raw: &Path,

486506 base_compressed: &Path,

487− status: Option<&StatusEmitter<'_>>,

488−) -> Result<()> {

507+ status: Option<&StatusFile>,

508+) -> Result<(), Box<dyn std::error::Error>> {

489509 if base_raw.exists() {

490510 return Ok(());

491511 }

492512

493513 if !base_compressed.exists()

494− || fs::metadata(base_compressed).map(|m| m.len())? < DEBIAN_COMPRESSED_SIZE_BYTES

514+ || std::fs::metadata(base_compressed).map(|m| m.len())? < DEBIAN_COMPRESSED_SIZE_BYTES

495515 {

496− emit_status(status, "downloading base image...");

516+ if let Some(status) = status {

517+ status.update("downloading base image...");

518+ }

497519 tracing::info!("downloading base image");

498520 let status = Command::new("curl")

499521 .args([

@@ -508,14 +530,15 @@ fn ensure_base_image(

508530 ])

509531 .status()?;

510532 if !status.success() {

511− bail!("failed to download base image");

533+ return Err("Failed to download base image".into());

512534 }

513535 }

514536

515537 // Check SHA

516538 {

517− emit_status(status, "verifying base image...");

518− tracing::info!("verifying base image...");

539+ if let Some(status) = status {

540+ status.update("verifying base image...");

541+ }

519542 let input = format!("{} {}\n", DEBIAN_COMPRESSED_SHA, base_compressed.display());

520543

521544 let mut child = Command::new("/usr/bin/shasum")

@@ -533,25 +556,25 @@ fn ensure_base_image(

533556

534557 let status = child.wait().expect("failed to wait on child");

535558 if !status.success() {

536− bail!(format!(

537− "SHA validation failed for {DEBIAN_COMPRESSED_DISK_URL}"

538− ));

559+ return Err(format!("SHA validation failed for {DEBIAN_COMPRESSED_DISK_URL}").into());

539560 }

540561 }

541562

542− emit_status(status, "decompressing base image...");

543− tracing::info!("decompressing base image...");

563+ if let Some(status) = status {

564+ status.update("decompressing base image...");

565+ }

566+ tracing::info!("decompressing base image");

544567 let status = Command::new("tar")

545568 .args([

546569 "-xOf",

547570 &base_compressed.to_string_lossy(),

548571 BASE_DISK_RAW_NAME,

549572 ])

550− .stdout(fs::File::create(base_raw)?)

573+ .stdout(std::fs::File::create(base_raw)?)

551574 .status()?;

552575

553576 if !status.success() {

554− bail!("Failed to decompress base image");

577+ return Err("Failed to decompress base image".into());

555578 }

556579

557580 Ok(())

@@ -562,20 +585,22 @@ fn ensure_default_image(

562585 base_compressed: &Path,

563586 default_raw: &Path,

564587 directory_shares: &[DirectoryShare],

588+ status: Option<&StatusFile>,

565589 provision_log: Option<&Path>,

566− status: Option<&StatusEmitter<'_>>,

567−) -> Result<()> {

590+) -> Result<(), Box<dyn std::error::Error>> {

568591 if default_raw.exists() {

569592 return Ok(());

570593 }

571594

572595 ensure_base_image(base_raw, base_compressed, status)?;

573596

574− emit_status(status, "configuring base image...");

575− tracing::info!("configuring base image...");

597+ if let Some(status) = status {

598+ status.update("configuring base image...");

599+ }

600+ tracing::info!("configuring base image");

576601 fs::copy(base_raw, default_raw)?;

577602

578− let provision_command = script_command_from_content("provision.sh", PROVISION_SCRIPT)?;

603+ let provision_command = script_command_from_content(PROVISION_SCRIPT_NAME, PROVISION_SCRIPT)?;

579604 let provision_actions = [

580605 Send(provision_command),

581606 ExpectEither {

@@ -590,9 +615,9 @@ fn ensure_default_image(

590615 default_raw,

591616 &provision_actions,

592617 directory_shares,

593− BoxConfig::default().cpu_count,

594− BoxConfig::default().ram_size.as_u64(),

595− status,

618+ DEFAULT_CPU_COUNT,

619+ DEFAULT_RAM_BYTES,

620+ None,

596621 move |output_monitor, vm_output_fd, vm_input_fd| {

597622 spawn_vm_io_with_log(output_monitor, vm_output_fd, vm_input_fd, log_path)

598623 },

@@ -602,9 +627,9 @@ fn ensure_default_image(

602627 default_raw,

603628 &provision_actions,

604629 directory_shares,

605− BoxConfig::default().cpu_count,

606− BoxConfig::default().ram_size.as_u64(),

607− status,

630+ DEFAULT_CPU_COUNT,

631+ DEFAULT_RAM_BYTES,

632+ None,

608633 )

609634 };

610635

@@ -619,16 +644,18 @@ fn ensure_default_image(

619644fn ensure_instance_disk(

620645 instance_raw: &Path,

621646 template_raw: &Path,

622− target_bytes: ByteSize,

623− status: Option<&StatusEmitter<'_>>,

624−) -> Result<bool> {

647+ target_bytes: u64,

648+ status: Option<&StatusFile>,

649+) -> Result<bool, Box<dyn std::error::Error>> {

625650 if instance_raw.exists() {

626− let current_size = ByteSize(fs::metadata(instance_raw)?.len());

651+ let current_size = fs::metadata(instance_raw)?.len();

627652 if current_size != target_bytes {

628− let current_gb = current_size;

629− let target_gb = target_bytes;

653+ let current_gb = current_size as f64 / (1024.0 * 1024.0 * 1024.0);

654+ let target_gb = target_bytes as f64 / (1024.0 * 1024.0 * 1024.0);

630655 tracing::warn!(

631− "instance disk size does not match config (current {}, config {}); disk_gb applies only on init. Run `vibebox reset` to recreate or set disk_gb to match; using existing disk.",

656+ current_bytes = current_size,

657+ target_bytes,

658+ "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.",

632659 current_gb,

633660 target_gb

634661 );

@@ -636,28 +663,30 @@ fn ensure_instance_disk(

636663 return Ok(false);

637664 }

638665

639− let template_size = ByteSize(fs::metadata(template_raw)?.len());

666+ let template_size = fs::metadata(template_raw)?.len();

640667 if target_bytes < template_size {

641− bail!(format!(

642− "Requested disk size {} is smaller than base image size {}",

668+ return Err(format!(

669+ "Requested disk size {} bytes is smaller than base image size {} bytes",

643670 target_bytes, template_size

644− ));

671+ )

672+ .into());

645673 }

646674 let target_size = target_bytes;

647675 let needs_resize = target_size > template_size;

648676

649− emit_status(status, "creating instance disk...");

650− tracing::info!("creating instance disk...");

677+ if let Some(status) = status {

678+ status.update("creating instance disk...");

679+ }

651680 tracing::info!(path = %template_raw.display(), "creating instance disk");

652− fs::create_dir_all(instance_raw.parent().unwrap())?;

681+ std::fs::create_dir_all(instance_raw.parent().unwrap())?;

653682 if target_size == template_size {

654683 fs::copy(template_raw, instance_raw)?;

655684 return Ok(needs_resize);

656685 }

657686

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)?;

687+ let mut dst = std::fs::File::create(instance_raw)?;

688+ dst.set_len(target_size)?;

689+ let mut src = std::fs::File::open(template_raw)?;

661690 std::io::copy(&mut src, &mut dst)?;

662691 Ok(needs_resize)

663692}

@@ -675,17 +704,18 @@ pub fn create_pipe() -> (OwnedFd, OwnedFd) {

675704 (read_stream.into(), write_stream.into())

676705}

677706

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−>(

707+pub fn spawn_vm_io_with_hooks<F, G>(

682708 output_monitor: Arc<OutputMonitor>,

683709 vm_output_fd: OwnedFd,

684710 vm_input_fd: OwnedFd,

685711 io_control: Arc<IoControl>,

686712 mut on_line: F,

687713 mut on_output: G,

688−) -> IoContext {

714+) -> IoContext

715+where

716+ F: FnMut(&str) -> bool + ::std::marker::Send + 'static,

717+ G: FnMut(&[u8]) + ::std::marker::Send + 'static,

718+{

689719 let (input_tx, input_rx): (Sender<VmInput>, Receiver<VmInput>) = mpsc::channel();

690720

691721 // raw_guard is set when we've put the user's terminal into raw mode because we've attached stdin/stdout to the VM.

@@ -833,14 +863,14 @@ pub fn spawn_vm_io_with_hooks<

833863 PollResult::Spurious => continue,

834864 PollResult::Ready(bytes) => {

835865 if io_control.forward_output() {

836− // enable raw mode if we haven't already

866+ // enable raw mode, if we haven't already

837867 if raw_guard.lock().unwrap().is_none()

838868 && let Ok(guard) = enable_raw_mode(libc::STDIN_FILENO)

839869 {

840870 *raw_guard.lock().unwrap() = Some(guard);

841871 }

842872

843− let mut stdout = io::stdout().lock();

873+ let mut stdout = std::io::stdout().lock();

844874 if stdout.write_all(bytes).is_err() {

845875 break;

846876 }

@@ -856,7 +886,7 @@ pub fn spawn_vm_io_with_hooks<

856886

857887 // Copies data from mpsc channel into VM, so vibe can "type" stuff and run scripts.

858888 let mux_thread = thread::spawn(move || {

859− let mut vm_writer = fs::File::from(vm_input_fd);

889+ let mut vm_writer = std::fs::File::from(vm_input_fd);

860890 loop {

861891 match input_rx.recv() {

862892 Ok(VmInput::Bytes(data)) => {

@@ -886,7 +916,7 @@ pub fn spawn_vm_io_with_line_handler<F>(

886916 on_line: F,

887917) -> IoContext

888918where

889− F: FnMut(&str) -> bool + std::marker::Send + 'static,

919+ F: FnMut(&str) -> bool + ::std::marker::Send + 'static,

890920{

891921 spawn_vm_io_with_hooks(

892922 output_monitor,

@@ -953,7 +983,7 @@ fn create_vm_configuration(

953983 vm_writes_to_fd: OwnedFd,

954984 cpu_count: usize,

955985 ram_bytes: u64,

956−) -> Result<Retained<VZVirtualMachineConfiguration>> {

986+) -> Result<Retained<VZVirtualMachineConfiguration>, Box<dyn std::error::Error>> {

957987 unsafe {

958988 let platform =

959989 VZGenericPlatformConfiguration::init(VZGenericPlatformConfiguration::alloc());

@@ -987,7 +1017,7 @@ fn create_vm_configuration(

9871017 false,

9881018 VZDiskImageCachingMode::Automatic,

9891019 VZDiskImageSynchronizationMode::Full,

990− )?;

1020+ ).unwrap();

9911021

9921022 let disk_device = VZVirtioBlockDeviceConfiguration::initWithAttachment(

9931023 VZVirtioBlockDeviceConfiguration::alloc(),

@@ -1074,7 +1104,7 @@ fn create_vm_configuration(

10741104 // Validate

10751105 config.validateWithError().map_err(|e| {

10761106 io::Error::other(format!(

1077− "invalid VM configuration: {:?}",

1107+ "Invalid VM configuration: {:?}",

10781108 e.localizedDescription()

10791109 ))

10801110 })?;

@@ -1083,9 +1113,9 @@ fn create_vm_configuration(

10831113 }

10841114}

10851115

1086−fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>> {

1116+fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>, Box<dyn std::error::Error>> {

10871117 unsafe {

1088− let temp_dir = env::temp_dir();

1118+ let temp_dir = std::env::temp_dir();

10891119 let temp_path = temp_dir.join(format!("efi_variable_store_{}.efivars", std::process::id()));

10901120 let url = nsurl_from_path(&temp_path)?;

10911121 let options = VZEFIVariableStoreInitializationOptions::AllowOverwrite;

@@ -1101,8 +1131,8 @@ fn load_efi_variable_store() -> Result<Retained<VZEFIVariableStore>> {

11011131fn spawn_login_actions_thread(

11021132 login_actions: Vec<LoginAction>,

11031133 output_monitor: Arc<OutputMonitor>,

1104− input_tx: Sender<VmInput>,

1105− vm_output_tx: Sender<VmOutput>,

1134+ input_tx: mpsc::Sender<VmInput>,

1135+ vm_output_tx: mpsc::Sender<VmOutput>,

11061136) -> thread::JoinHandle<()> {

11071137 thread::spawn(move || {

11081138 for a in login_actions {

@@ -1152,9 +1182,9 @@ fn run_vm_with_io<F>(

11521182 directory_shares: &[DirectoryShare],

11531183 cpu_count: usize,

11541184 ram_bytes: u64,

1155− status: Option<&StatusEmitter<'_>>,

1185+ status: Option<&StatusFile>,

11561186 io_handler: F,

1157−) -> Result<()>

1187+) -> Result<(), Box<dyn std::error::Error>>

11581188where

11591189 F: FnOnce(Arc<OutputMonitor>, OwnedFd, OwnedFd) -> IoContext,

11601190{

@@ -1201,22 +1231,23 @@ where

12011231

12021232 match rx.try_recv() {

12031233 Ok(result) => {

1204− result.map_err(|e| Error::msg(format!("Failed to start VM: {}", e)))?;

1234+ result.map_err(|e| format!("Failed to start VM: {}", e))?;

12051235 break;

12061236 }

12071237 Err(mpsc::TryRecvError::Empty) => continue,

12081238 Err(mpsc::TryRecvError::Disconnected) => {

1209− bail!("VM start channel disconnected");

1239+ return Err("VM start channel disconnected".into());

12101240 }

12111241 }

12121242 }

12131243

12141244 if Instant::now() >= start_deadline {

1215− bail!("Timed out waiting for VM to start");

1245+ return Err("Timed out waiting for VM to start".into());

12161246 }

12171247

1218− emit_status(status, "vm booting... go vibecoder!");

1219− tracing::info!("vm booting... go vibecoder!");

1248+ if let Some(status) = status {

1249+ status.update("vm booting... go vibecoder!");

1250+ }

12201251 tracing::info!("vm booting");

12211252

12221253 let output_monitor = Arc::new(OutputMonitor::default());

@@ -1262,7 +1293,7 @@ where

12621293 );

12631294

12641295 let mut last_state = None;

1265− let mut exit_result: Result<(), String> = Ok(());

1296+ let mut exit_result = Ok(());

12661297 loop {

12671298 unsafe {

12681299 NSRunLoop::mainRunLoop().runMode_beforeDate(

@@ -1281,7 +1312,8 @@ where

12811312 exit_result = Err(format!(

12821313 "Login action ({}) timed out after {:?}; shutting down.",

12831314 action, timeout

1284− ));

1315+ )

1316+ .into());

12851317 unsafe {

12861318 if vm.canRequestStop() {

12871319 if let Err(err) = vm.requestStopWithError() {

@@ -1298,7 +1330,8 @@ where

12981330 exit_result = Err(format!(

12991331 "Login action ({}) failed: {}; shutting down.",

13001332 action, reason

1301− ));

1333+ )

1334+ .into());

13021335 unsafe {

13031336 if vm.canRequestStop() {

13041337 if let Err(err) = vm.requestStopWithError() {

@@ -1314,7 +1347,7 @@ where

13141347 Err(mpsc::TryRecvError::Empty) => {}

13151348 Err(mpsc::TryRecvError::Disconnected) => {}

13161349 }

1317− if state != VZVirtualMachineState::Running {

1350+ if state != objc2_virtualization::VZVirtualMachineState::Running {

13181351 //eprintln!("VM stopped with state: {:?}", state);

13191352 break;

13201353 }

@@ -1324,7 +1357,7 @@ where

13241357

13251358 io_ctx.shutdown();

13261359

1327− exit_result.map_err(Error::msg)

1360+ exit_result

13281361}

13291362

13301363fn run_vm(

@@ -1333,8 +1366,8 @@ fn run_vm(

13331366 directory_shares: &[DirectoryShare],

13341367 cpu_count: usize,

13351368 ram_bytes: u64,

1336− status: Option<&StatusEmitter<'_>>,

1337−) -> Result<()> {

1369+ status: Option<&StatusFile>,

1370+) -> Result<(), Box<dyn std::error::Error>> {

13381371 run_vm_with_io(

13391372 disk_path,

13401373 login_actions,

@@ -1346,7 +1379,7 @@ fn run_vm(

13461379 )

13471380}

13481381

1349−fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>> {

1382+fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>, Box<dyn std::error::Error>> {

13501383 let abs_path = if path.is_absolute() {

13511384 path.to_path_buf()

13521385 } else {

@@ -1355,7 +1388,7 @@ fn nsurl_from_path(path: &Path) -> Result<Retained<NSURL>> {

13551388 let ns_path = NSString::from_str(

13561389 abs_path

13571390 .to_str()

1358− .with_context(|| "non-UTF8 path encountered while building NSURL")?,

1391+ .ok_or("Non-UTF8 path encountered while building NSURL")?,

13591392 );

13601393 Ok(NSURL::fileURLWithPath(&ns_path))

13611394}

@@ -1370,7 +1403,7 @@ fn enable_raw_mode(fd: i32) -> io::Result<RawModeGuard> {

13701403 let original = attributes;

13711404

13721405 // Disable translation of carriage return to newline on input

1373− attributes.c_iflag &= !libc::ICRNL;

1406+ attributes.c_iflag &= !(libc::ICRNL);

13741407 // Disable canonical mode (line buffering), echo, and signal generation

13751408 attributes.c_lflag &= !(libc::ICANON | libc::ECHO | libc::ISIG);

13761409 attributes.c_cc[libc::VMIN] = 0;

@@ -1398,10 +1431,10 @@ impl Drop for RawModeGuard {

13981431

13991432// Ensure the running binary has com.apple.security.virtualization entitlements by checking and, if not, signing and relaunching.

14001433pub fn ensure_signed() {

1401− if env::var("VIBEBOX_SKIP_CODESIGN").as_deref() == Ok("1") {

1434+ if std::env::var("VIBEBOX_SKIP_CODESIGN").as_deref() == Ok("1") {

14021435 return;

14031436 }

1404− let exe = env::current_exe().expect("failed to get current exe path");

1437+ let exe = std::env::current_exe().expect("failed to get current exe path");

14051438 let exe_str = exe.to_str().expect("exe path not valid utf-8");

14061439

14071440 let has_required_entitlements = {

@@ -1423,8 +1456,8 @@ pub fn ensure_signed() {

14231456 }

14241457

14251458 const ENTITLEMENTS: &str = include_str!("entitlements.plist");

1426− let entitlements_path = env::temp_dir().join("entitlements.plist");

1427− fs::write(&entitlements_path, ENTITLEMENTS).expect("failed to write entitlements");

1459+ let entitlements_path = std::env::temp_dir().join("entitlements.plist");

1460+ std::fs::write(&entitlements_path, ENTITLEMENTS).expect("failed to write entitlements");

14281461

14291462 let output = Command::new("codesign")

14301463 .args([

@@ -1437,7 +1470,7 @@ pub fn ensure_signed() {

14371470 ])

14381471 .output();

14391472

1440− let _ = fs::remove_file(&entitlements_path);

1473+ let _ = std::fs::remove_file(&entitlements_path);

14411474

14421475 match output {

14431476 Ok(o) if o.status.success() => {

@@ -1445,7 +1478,7 @@ pub fn ensure_signed() {

14451478 if !stderr.trim().is_empty() {

14461479 tracing::debug!(codesign_stderr = %stderr.trim(), "codesign output");

14471480 }

1448− let err = Command::new(&exe).args(env::args_os().skip(1)).exec();

1481+ let err = Command::new(&exe).args(std::env::args_os().skip(1)).exec();

14491482 tracing::error!(error = %err, "failed to re-exec after signing");

14501483 std::process::exit(1);

14511484 }

src/vm_manager.rs+114−204

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

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};

131use std::{

142 env, fs,

153 io::{Read, Write},

164 os::unix::{

5+ fs::FileTypeExt,

176 fs::PermissionsExt,

187 io::AsRawFd,

198 net::{UnixListener, UnixStream},

9+ process::CommandExt,

2010 },

2111 path::{Path, PathBuf},

2212 process::{Command, Stdio},

@@ -25,8 +15,20 @@ use std::{

2515 time::{Duration, Instant},

2616};

2717

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

29−const VM_ROOT_LOG_NAME: &str = "vm_root.log";

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+

3032const VM_MANAGER_LOCK_NAME: &str = "vm.lock";

3133const VM_MANAGER_LOG_NAME: &str = "vm_manager.log";

3234const SHUTDOWN_RETRY_MS: u64 = 500;

@@ -34,10 +36,6 @@ const SHUTDOWN_RETRY_MS: u64 = 500;

3436const HARD_SHUTDOWN_TIMEOUT_MS: u64 = 1_000;

3537#[cfg(not(test))]

3638const 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>>;

4139

4240#[cfg(not(test))]

4341fn force_exit(_reason: &str) -> ! {

@@ -53,16 +51,16 @@ pub fn ensure_manager(

5351 raw_args: &[std::ffi::OsString],

5452 auto_shutdown_ms: u64,

5553 config_path: Option<&Path>,

56−) -> Result<UnixStream> {

54+) -> Result<UnixStream, Box<dyn std::error::Error>> {

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

5856 tracing::debug!(root = %project_root.display(), "ensure vm manager");

5957 let instance_dir = ensure_instance_dir(&project_root)?;

60− cleanup_stale_manager(&project_root)?;

58+ cleanup_stale_manager(&instance_dir);

6159 let socket_path = instance_dir.join(VM_MANAGER_SOCKET_NAME);

6260

6361 if let Ok(stream) = UnixStream::connect(&socket_path) {

6462 send_client_pid(&stream);

65− tracing::info!(path = %socket_path.display(), "connected to an existing vm manager");

63+ tracing::info!(path = %socket_path.display(), "connected to existing vm manager");

6664 return Ok(stream);

6765 }

6866

@@ -100,11 +98,12 @@ pub fn ensure_manager(

10098 drop(lock_file.take());

10199 let _ = fs::remove_file(&lock_path);

102100 }

103− bail!(format!(

104− "timed out waiting for vm manager socket: {} ({})",

101+ return Err(format!(

102+ "Timed out waiting for vm manager socket: {} ({})",

105103 socket_path.display(),

106104 err

107− ));

105+ )

106+ .into());

108107 }

109108 thread::sleep(Duration::from_millis(100));

110109 }

@@ -112,19 +111,12 @@ pub fn ensure_manager(

112111 }

113112}

114113

115−pub fn run_manager(args: vm::VmArg, auto_shutdown_ms: u64) -> Result<()> {

114+pub fn run_manager(

115+ args: vm::VmArg,

116+ auto_shutdown_ms: u64,

117+) -> Result<(), Box<dyn std::error::Error>> {

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

117119 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− }

128120 let _pid_guard = ensure_pid_file(&project_root)?;

129121 #[cfg(feature = "mock-vm")]

130122 tracing::info!("vm manager using mock executor");

@@ -142,6 +134,7 @@ pub fn run_manager(args: vm::VmArg, auto_shutdown_ms: u64) -> Result<()> {

142134 #[cfg(feature = "mock-vm")]

143135 {

144136 ManagerOptions {

137+ ensure_signed: false,

145138 detach: true,

146139 prepare_vm: false,

147140 }

@@ -149,6 +142,7 @@ pub fn run_manager(args: vm::VmArg, auto_shutdown_ms: u64) -> Result<()> {

149142 #[cfg(not(feature = "mock-vm"))]

150143 {

151144 ManagerOptions {

145+ ensure_signed: true,

152146 detach: true,

153147 prepare_vm: true,

154148 }

@@ -162,22 +156,25 @@ fn spawn_manager_process(

162156 auto_shutdown_ms: u64,

163157 instance_dir: &Path,

164158 config_path: Option<&Path>,

165−) -> Result<()> {

159+) -> Result<(), Box<dyn std::error::Error>> {

166160 let exe = env::current_exe()?;

167161 let mut supervisor_exe = exe.clone();

168162 supervisor_exe.set_file_name("vibebox-supervisor");

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);

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+ };

177171 if raw_args.len() > 1 {

178172 cmd.args(&raw_args[1..]);

179173 }

180174 cmd.env("VIBEBOX_INTERNAL", "1");

175+ if !use_supervisor {

176+ cmd.env("VIBEBOX_VM_MANAGER", "1");

177+ }

181178 cmd.env("VIBEBOX_LOG_NO_COLOR", "1");

182179 cmd.env("VIBEBOX_AUTO_SHUTDOWN_MS", auto_shutdown_ms.to_string());

183180 if let Some(path) = config_path {

@@ -205,22 +202,22 @@ fn spawn_manager_process(

205202 Ok(())

206203}

207204

208−fn ensure_pid_file(project_root: &Path) -> Result<PidFileGuard> {

205+fn ensure_pid_file(project_root: &Path) -> Result<PidFileGuard, Box<dyn std::error::Error>> {

209206 let instance_dir = ensure_instance_dir(project_root)?;

210207 let pid_path = instance_dir.join(VM_MANAGER_PID_NAME);

211208 let socket_path = instance_dir.join(VM_MANAGER_SOCKET_NAME);

212− match vm_liveness(project_root)? {

213− VmLiveness::RunningWithSocket { pid } => {

214− bail!("vm manager already running (pid {pid})");

215− }

216− VmLiveness::RunningWithoutSocket { pid } => {

217− tracing::warn!(

218− pid,

219− path = %socket_path.display(),

220− "stale pid file detected with missing socket"

221− );

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());

222215 }

223− VmLiveness::NotRunningOrMissing => {}

216+ tracing::warn!(

217+ pid,

218+ path = %socket_path.display(),

219+ "stale pid file detected with missing socket"

220+ );

224221 }

225222 let _ = fs::remove_file(&pid_path);

226223 fs::write(&pid_path, format!("{}\n", std::process::id()))?;

@@ -228,18 +225,15 @@ fn ensure_pid_file(project_root: &Path) -> Result<PidFileGuard> {

228225 Ok(PidFileGuard { path: pid_path })

229226}

230227

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(());

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;

240235 }

241236 let _ = fs::remove_file(&pid_path);

242− Ok(())

243237}

244238

245239fn inject_project_mount(

@@ -266,6 +260,12 @@ fn inject_project_mount(

266260 mounts.insert(0, format!("{host}:{guest_tilde}:read-write"));

267261}

268262

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,30 +409,6 @@ 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−

436412fn send_client_pid(stream: &UnixStream) {

437413 let pid = std::process::id();

438414 let payload = format!("pid={pid}\n");

@@ -442,7 +418,7 @@ fn send_client_pid(stream: &UnixStream) {

442418 }

443419}

444420

445−fn acquire_spawn_lock(lock_path: &Path) -> Result<Option<fs::File>> {

421+fn acquire_spawn_lock(lock_path: &Path) -> Result<Option<fs::File>, Box<dyn std::error::Error>> {

446422 match fs::OpenOptions::new()

447423 .write(true)

448424 .create_new(true)

@@ -476,12 +452,6 @@ fn is_lock_stale(lock_path: &Path) -> bool {

476452 }

477453}

478454

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−

485455fn pid_is_alive(pid: u32) -> bool {

486456 let pid = pid as libc::pid_t;

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

@@ -495,6 +465,12 @@ fn pid_is_alive(pid: u32) -> bool {

495465 }

496466}

497467

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+

498474fn read_client_pid(stream: &UnixStream) -> Option<u32> {

499475 let mut stream = stream.try_clone().ok()?;

500476 let _ = stream.set_read_timeout(Some(Duration::from_millis(200)));

@@ -530,14 +506,12 @@ fn read_client_pid(stream: &UnixStream) -> Option<u32> {

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

531507fn spawn_manager_io(

532508 config: Arc<Mutex<InstanceConfig>>,

533− project_dir: PathBuf,

534− clients: ClientStreams,

535− latest_status: SharedStatus,

509+ instance_dir: PathBuf,

536510 output_monitor: Arc<vm::OutputMonitor>,

537511 vm_output_fd: std::os::unix::io::OwnedFd,

538512 vm_input_fd: std::os::unix::io::OwnedFd,

539513) -> vm::IoContext {

540− let log_path = project_dir.join(INSTANCE_DIR_NAME).join(VM_ROOT_LOG_NAME);

514+ let log_path = instance_dir.join(VM_ROOT_LOG_NAME);

541515 let log_file = fs::OpenOptions::new()

542516 .create(true)

543517 .write(true)

@@ -546,6 +520,7 @@ fn spawn_manager_io(

546520 .ok()

547521 .map(|file| Arc::new(Mutex::new(file)));

548522

523+ let instance_path = instance_dir.join(INSTANCE_FILENAME);

549524 let config_for_output = config.clone();

550525 let log_for_output = log_file.clone();

551526 let mut line_buf = String::new();

@@ -568,17 +543,6 @@ fn spawn_manager_io(

568543 line_buf.drain(..=pos);

569544

570545 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− }

582546 if let Some(pos) = cleaned.find("VIBEBOX_IPV4=") {

583547 let ip_raw = &cleaned[(pos + "VIBEBOX_IPV4=".len())..];

584548 let ip = extract_ipv4(ip_raw).unwrap_or_default();

@@ -587,7 +551,7 @@ fn spawn_manager_io(

587551 && cfg.vm_ipv4.as_deref() != Some(ip.as_str())

588552 {

589553 cfg.vm_ipv4 = Some(ip.clone());

590− let _ = write_instance_config(&project_dir, &cfg);

554+ let _ = write_instance_config(&instance_path, &cfg);

591555 }

592556 }

593557 }

@@ -610,12 +574,12 @@ enum ManagerEvent {

610574}

611575

612576struct ManagerOptions {

577+ ensure_signed: bool,

613578 detach: bool,

614579 prepare_vm: bool,

615580}

616581

617582trait VmExecutor {

618− #[allow(clippy::too_many_arguments)]

619583 fn run_vm(

620584 &self,

621585 args: vm::VmArg,

@@ -623,10 +587,8 @@ trait VmExecutor {

623587 extra_shares: Vec<DirectoryShare>,

624588 config: Arc<Mutex<InstanceConfig>>,

625589 instance_dir: PathBuf,

626− clients: ClientStreams,

627− latest_status: SharedStatus,

628590 vm_input_tx: Arc<Mutex<Option<mpsc::Sender<VmInput>>>>,

629− ) -> Result<()>;

591+ ) -> Result<(), Box<dyn std::error::Error>>;

630592}

631593

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

@@ -639,22 +601,15 @@ impl VmExecutor for RealVmExecutor {

639601 extra_login_actions: Vec<LoginAction>,

640602 extra_shares: Vec<DirectoryShare>,

641603 config: Arc<Mutex<InstanceConfig>>,

642− project_dir: PathBuf,

643− clients: ClientStreams,

644− latest_status: SharedStatus,

604+ instance_dir: PathBuf,

645605 vm_input_tx: Arc<Mutex<Option<mpsc::Sender<VmInput>>>>,

646− ) -> Result<()> {

647− let status_callback = |status: &str| {

648− broadcast_status(&clients, &latest_status, status);

649− };

606+ ) -> Result<(), Box<dyn std::error::Error>> {

650607 vm::run_with_args_and_extras(

651608 args,

652609 |output_monitor, vm_output_fd, vm_input_fd| {

653610 let io_ctx = spawn_manager_io(

654611 config.clone(),

655− project_dir.clone(),

656− clients.clone(),

657− latest_status.clone(),

612+ instance_dir.clone(),

658613 output_monitor,

659614 vm_output_fd,

660615 vm_input_fd,

@@ -664,7 +619,6 @@ impl VmExecutor for RealVmExecutor {

664619 },

665620 extra_login_actions,

666621 extra_shares,

667− Some(&status_callback),

668622 )

669623 }

670624}

@@ -681,10 +635,8 @@ impl VmExecutor for MockVmExecutor {

681635 _extra_shares: Vec<DirectoryShare>,

682636 _config: Arc<Mutex<InstanceConfig>>,

683637 _instance_dir: PathBuf,

684− _clients: ClientStreams,

685− _latest_status: SharedStatus,

686638 vm_input_tx: Arc<Mutex<Option<mpsc::Sender<VmInput>>>>,

687− ) -> Result<()> {

639+ ) -> Result<(), Box<dyn std::error::Error>> {

688640 let (tx, rx) = mpsc::channel::<VmInput>();

689641 *vm_input_tx.lock().unwrap() = Some(tx);

690642 tracing::info!("mock vm executor running");

@@ -710,14 +662,24 @@ fn run_manager_with(

710662 auto_shutdown_ms: u64,

711663 executor: &dyn VmExecutor,

712664 options: ManagerOptions,

713−) -> Result<()> {

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+ }

714676 if options.detach {

715677 detach_from_terminal();

716678 }

717679

718680 let project_name = project_root

719681 .file_name()

720− .ok_or_else(|| anyhow!("Project directory has no name"))?

682+ .ok_or("Project directory has no name")?

721683 .to_string_lossy()

722684 .into_owned();

723685 let instance_dir = ensure_instance_dir(project_root)?;

@@ -725,16 +687,16 @@ fn run_manager_with(

725687 let _ = ensure_ssh_keypair(&instance_dir)?;

726688 }

727689

728− let mut config = load_or_create_instance_config(project_root)?;

690+ let mut config = load_or_create_instance_config(&instance_dir)?;

729691 if config.vm_ipv4.is_some() {

730692 config.vm_ipv4 = None;

731− write_instance_config(project_root, &config)?;

693+ write_instance_config(&instance_dir.join(INSTANCE_FILENAME), &config)?;

732694 }

733695 let config = Arc::new(Mutex::new(config));

734696 let ssh_user = config

735697 .lock()

736− .map(|cfg| cfg.ssh_user.clone())

737− .map_err(|_| anyhow!("failed to acquire ssh user display"))?;

698+ .map(|cfg| cfg.ssh_user_display())

699+ .unwrap_or_else(|_| DEFAULT_SSH_USER.to_string());

738700 if !args.no_default_mounts {

739701 inject_project_mount(&mut args.mounts, project_root, &ssh_user, &project_name);

740702 }

@@ -742,10 +704,11 @@ fn run_manager_with(

742704

743705 let project_guest_dir = format!("{PROJECT_GUEST_BASE}/{project_name}");

744706 let ssh_guest_dir = format!("/root/{}", GLOBAL_DIR_NAME);

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− ];

707+ let extra_shares = vec![DirectoryShare::new(

708+ instance_dir.clone(),

709+ ssh_guest_dir.clone().into(),

710+ true,

711+ )?];

749712 let extra_login_actions = build_ssh_login_actions(

750713 &config,

751714 &project_name,

@@ -768,43 +731,17 @@ fn run_manager_with(

768731 let _ = fs::set_permissions(&socket_path, fs::Permissions::from_mode(0o600));

769732 tracing::info!(path = %socket_path.display(), "vm manager socket bound");

770733

771− let clients: ClientStreams = Arc::new(Mutex::new(Vec::new()));

772− let latest_status: SharedStatus = Arc::new(Mutex::new(String::new()));

773734 let (event_tx, event_rx) = mpsc::channel::<ManagerEvent>();

774735 let event_tx_accept = event_tx.clone();

775− let clients_accept = clients.clone();

776− let latest_status_accept = latest_status.clone();

777736 thread::spawn(move || {

778737 for stream in listener.incoming() {

779738 match stream {

780739 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− }

799740 let event_tx_conn = event_tx_accept.clone();

800− let clients_conn = clients_accept.clone();

801741 thread::spawn(move || {

802742 let pid = read_client_pid(&stream);

803743 let _ = event_tx_conn.send(ManagerEvent::Inc(pid));

804744 wait_for_disconnect(stream);

805− if let Some(fd) = client_fd {

806− remove_client(&clients_conn, fd);

807− }

808745 let _ = event_tx_conn.send(ManagerEvent::Dec(pid));

809746 });

810747 }

@@ -824,43 +761,38 @@ fn run_manager_with(

824761 extra_login_actions,

825762 extra_shares,

826763 config.clone(),

827− project_root.to_path_buf(),

828− clients.clone(),

829− latest_status.clone(),

764+ instance_dir.clone(),

830765 vm_input_tx.clone(),

831766 );

832767 tracing::info!("vm manager vm run completed");

833768 let vm_err = vm_result.err().map(|e| e.to_string());

834769 if let Some(err) = &vm_err {

835− broadcast_status(

836− &clients,

837− &latest_status,

838− &format!("{STATUS_VM_ERROR_PREFIX} {err}"),

839− );

770+ let status_path = instance_dir.join(STATUS_FILE_NAME);

771+ let _ = fs::write(&status_path, format!("error: {err}"));

840772 }

841773 let _ = event_tx.send(ManagerEvent::VmExited(vm_err.clone()));

842− let event_loop_result = event_loop_handle

774+ let event_loop_result: Result<(), String> = event_loop_handle

843775 .join()

844− .unwrap_or_else(|_| Err(Error::msg("vm manager event loop panicked")))

776+ .unwrap_or_else(|_| Err("vm manager event loop panicked".into()))

845777 .map_err(|err| err.to_string());

846778 let _ = fs::remove_file(&socket_path);

847779 if let Err(err) = &event_loop_result {

848780 tracing::error!(error = %err, "vm manager exiting due to event loop error");

849− bail!(err.to_string());

781+ return Err(err.to_string().into());

850782 }

851783 if let Some(err) = vm_err {

852784 tracing::error!(error = %err, "vm manager exiting due to vm error");

853− bail!(err);

785+ return Err(err.into());

854786 }

855787 tracing::info!("vm manager exiting");

856− event_loop_result.map_err(Error::msg)

788+ Ok(event_loop_result?)

857789}

858790

859791fn manager_event_loop(

860792 event_rx: mpsc::Receiver<ManagerEvent>,

861793 vm_input_tx: Arc<Mutex<Option<mpsc::Sender<VmInput>>>>,

862794 auto_shutdown_ms: u64,

863−) -> Result<()> {

795+) -> Result<(), String> {

864796 let mut ref_count: usize = 0;

865797 let mut shutdown_deadline: Option<Instant> = None;

866798 let mut shutdown_sent = false;

@@ -970,7 +902,7 @@ fn manager_event_loop(

970902#[cfg(test)]

971903mod tests {

972904 use super::*;

973− use std::{fs, sync::mpsc, thread, time::Duration};

905+ use std::{sync::mpsc, thread, time::Duration};

974906

975907 #[test]

976908 fn manager_powers_off_after_grace_when_no_refs() {

@@ -1052,26 +984,4 @@ mod tests {

1052984 let _ = event_tx.send(ManagerEvent::VmExited(None));

1053985 let _ = manager_thread.join();

1054986 }

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− }

1077987}