feat: interactive mode, daemon logging, fresh setup, HOME env

Interactive mode (vz run -i):
- Terminal set to raw mode via crossterm
- Stdin forwarded to guest PTY via write_exec_stdin RPC
- Arrow keys, ctrl sequences, paste all work
- Terminal restored on exit
- Tested: compiled+ran Rust in interactive bash session

Daemon logging:
- Daemon writes log file directly via tracing with_writer (not stderr)
- Fixes empty log file issue (tracing to stderr + file redirect didn't flush)
- vz logs now shows daemon output immediately
- Smarter error when daemon predates log support

Other fixes:
- HOME=/root set in both setup exec and run exec (rustup, npm need it)
- --fresh now clears setup hash on both host and guest (forces re-run)
- getcwd() warning filtered in setup output (was only filtered in run)
- Stale state store lock files cleaned up on daemon spawn
- Stale log file removed on daemon restart

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: lightsofapollo

crates/vz-cli/src/commands/dev.rs

@@ -7,9 +7,12 @@
 use std::collections::{BTreeMap, HashMap};
 use std::io::Write as _;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use anyhow::{Context, anyhow, bail};
 use clap::Args;
+use crossterm::terminal;
 use serde::Deserialize;
 use sha2::{Digest, Sha256};
 use tracing::debug;
@@ -235,6 +238,19 @@ pub async fn cmd_run(args: DevRunArgs) -> anyhow::Result<()> {
         eprintln!("VM ready.");
 
         // Run setup commands if needed.
+        // When --fresh, force re-run by clearing any cached hashes.
+        if args.fresh {
+            if let Ok(path) = host_setup_hash_path(&sandbox_id) {
+                let _ = std::fs::remove_file(path);
+            }
+            let container_id = resolve_container(&mut client, &sandbox_id).await?;
+            let _ = exec_quiet(
+                &mut client,
+                &container_id,
+                "rm -f /run/vz-oci/volumes/.vz-setup-hash",
+            )
+            .await;
+        }
         run_setup_if_needed(&mut client, &sandbox_id, &config).await?;
     }
 
@@ -245,6 +261,11 @@ pub async fn cmd_run(args: DevRunArgs) -> anyhow::Result<()> {
     let shell_command = args.command.join(" ");
     let mut env_map = config.env.clone();
 
+    // Ensure HOME is always set — many tools (rustup, npm, etc.) depend on it.
+    if !env_map.contains_key("HOME") {
+        env_map.insert("HOME".to_string(), "/root".to_string());
+    }
+
     // Auto-detect Rust projects and set CARGO_TARGET_DIR to persistent disk
     // so build artifacts survive VM restarts.
     if !env_map.contains_key("CARGO_TARGET_DIR") && project_dir.join("Cargo.toml").exists() {
@@ -295,7 +316,69 @@ pub async fn cmd_run(args: DevRunArgs) -> anyhow::Result<()> {
     let execution_payload = execution
         .execution
         .ok_or_else(|| anyhow!("daemon missing execution payload"))?;
-    let execution_id = execution_payload.execution_id;
+    let execution_id = execution_payload.execution_id.clone();
+
+    // For interactive mode: enable raw terminal and forward stdin to the PTY.
+    let stdin_stop = Arc::new(AtomicBool::new(false));
+    let stdin_handle = if args.interactive {
+        terminal::enable_raw_mode().context("failed to enable raw mode")?;
+
+        let stop = Arc::clone(&stdin_stop);
+        let exec_id = execution_id.clone();
+        let mut stdin_client = client.clone();
+        Some(tokio::task::spawn_blocking(move || {
+            use crossterm::event::{self, Event, KeyCode, KeyEventKind, KeyModifiers};
+            while !stop.load(Ordering::Relaxed) {
+                if !event::poll(std::time::Duration::from_millis(100)).unwrap_or(false) {
+                    continue;
+                }
+                let Ok(ev) = event::read() else { break };
+                let bytes = match ev {
+                    Event::Key(key)
+                        if matches!(key.kind, KeyEventKind::Press | KeyEventKind::Repeat) =>
+                    {
+                        match key.code {
+                            KeyCode::Char(c)
+                                if key.modifiers.contains(KeyModifiers::CONTROL) =>
+                            {
+                                vec![c as u8 & 0x1f]
+                            }
+                            KeyCode::Char(c) => {
+                                let mut buf = [0u8; 4];
+                                c.encode_utf8(&mut buf);
+                                buf[..c.len_utf8()].to_vec()
+                            }
+                            KeyCode::Enter => vec![b'\r'],
+                            KeyCode::Backspace => vec![0x7f],
+                            KeyCode::Tab => vec![b'\t'],
+                            KeyCode::Esc => vec![0x1b],
+                            KeyCode::Up => vec![0x1b, b'[', b'A'],
+                            KeyCode::Down => vec![0x1b, b'[', b'B'],
+                            KeyCode::Right => vec![0x1b, b'[', b'C'],
+                            KeyCode::Left => vec![0x1b, b'[', b'D'],
+                            KeyCode::Home => vec![0x1b, b'[', b'H'],
+                            KeyCode::End => vec![0x1b, b'[', b'F'],
+                            KeyCode::Delete => vec![0x1b, b'[', b'3', b'~'],
+                            _ => continue,
+                        }
+                    }
+                    Event::Paste(text) => text.into_bytes(),
+                    _ => continue,
+                };
+
+                let rt = tokio::runtime::Handle::current();
+                let _ = rt.block_on(stdin_client.write_exec_stdin(
+                    runtime_v2::WriteExecStdinRequest {
+                        execution_id: exec_id.clone(),
+                        data: bytes,
+                        metadata: None,
+                    },
+                ));
+            }
+        }))
+    } else {
+        None
+    };
 
     let mut stream = client
         .stream_exec_output(runtime_v2::StreamExecOutputRequest {
@@ -317,21 +400,31 @@ pub async fn cmd_run(args: DevRunArgs) -> anyhow::Result<()> {
                 let _ = std::io::stdout().flush();
             }
             Some(runtime_v2::exec_output_event::Payload::Stderr(bytes)) => {
-                // Filter the harmless getcwd() warning from the shell.
-                // The kernel's getcwd() syscall fails with stacked
-                // overlay+VirtioFS mounts but CWD is actually correct.
                 write_filtered_stderr(&bytes);
             }
             Some(runtime_v2::exec_output_event::Payload::ExitCode(code)) => {
                 exit_code = code;
             }
             Some(runtime_v2::exec_output_event::Payload::Error(error)) => {
+                if args.interactive {
+                    stdin_stop.store(true, Ordering::Relaxed);
+                    let _ = terminal::disable_raw_mode();
+                }
                 bail!("execution error: {error}");
             }
             None => {}
         }
     }
 
+    // Clean up interactive mode.
+    if args.interactive {
+        stdin_stop.store(true, Ordering::Relaxed);
+        let _ = terminal::disable_raw_mode();
+        if let Some(handle) = stdin_handle {
+            let _ = tokio::time::timeout(std::time::Duration::from_secs(2), handle).await;
+        }
+    }
+
     if exit_code != 0 {
         std::process::exit(exit_code);
     }
@@ -704,7 +797,9 @@ async fn exec_streaming(
                 "-c".to_string(),
                 format!("cd / && {command}"),
             ],
-            env_override: HashMap::new(),
+            env_override: HashMap::from([
+                ("HOME".to_string(), "/root".to_string()),
+            ]),
             timeout_secs: 3600,
             pty_mode: runtime_v2::create_execution_request::PtyMode::Disabled as i32,
         })
@@ -731,8 +826,7 @@ async fn exec_streaming(
                 let _ = std::io::stdout().flush();
             }
             Some(runtime_v2::exec_output_event::Payload::Stderr(bytes)) => {
-                let _ = std::io::stderr().write_all(&bytes);
-                let _ = std::io::stderr().flush();
+                write_filtered_stderr(&bytes);
             }
             Some(runtime_v2::exec_output_event::Payload::ExitCode(code)) => {
                 exit_code = Some(code);

crates/vz-cli/src/commands/dev_logs.rs

@@ -23,15 +23,24 @@ pub async fn cmd_dev_logs(args: DevLogsArgs) -> anyhow::Result<()> {
     let log_path = resolve_log_path()?;
 
     if !log_path.exists() {
+        // Check if the daemon socket exists — if so, the daemon was started
+        // before log-file support was added.
+        let socket_path = log_path.with_extension("sock");
+        if socket_path.exists() {
+            bail!(
+                "no log file found (daemon was started before log support).\n\
+                 Restart the daemon to enable logging:\n\
+                 \n  vz stop && vz run <command>"
+            );
+        }
         bail!(
             "no daemon log file found at {}\n\
-             The daemon may not have been started yet. Run `vz run` first.",
+             The daemon has not been started yet. Run `vz run` first.",
             log_path.display()
         );
     }
 
     if args.follow {
-        // Use tail -f for follow mode.
         let status = std::process::Command::new("tail")
             .arg("-f")
             .arg("-n")

crates/vz-runtimed-client/src/lib.rs

@@ -348,17 +348,41 @@ impl DaemonClient {
 
         // Remove stale socket so spawn_daemon gets a clean bind.
         let _ = std::fs::remove_file(socket_path);
+        // Remove stale log file so the new daemon gets a fresh one.
+        let _ = std::fs::remove_file(socket_path.with_extension("log"));
 
         // Brief pause for process cleanup.
         std::thread::sleep(Duration::from_millis(200));
     }
 
+    /// Remove stale state store lock files that prevent daemon startup.
+    ///
+    /// Called before spawning to clean up after ungraceful daemon termination.
+    fn clean_stale_lock(config: &DaemonClientConfig) {
+        if let Some(state_store_path) = &config.state_store_path {
+            let lock_path = state_store_path.with_extension("db.lock");
+            if lock_path.exists() {
+                let _ = std::fs::remove_file(&lock_path);
+            }
+            // Also try without the .db extension in case the path doesn't end in .db
+            let mut lock_path_alt = state_store_path.as_os_str().to_owned();
+            lock_path_alt.push(".lock");
+            let lock_path_alt = Path::new(&lock_path_alt);
+            if lock_path_alt.exists() {
+                let _ = std::fs::remove_file(lock_path_alt);
+            }
+        }
+    }
+
     fn spawn_daemon(config: &DaemonClientConfig) -> Result<()> {
         let binary = resolve_daemon_binary(config)?;
         if !binary.exists() {
             return Err(DaemonClientError::BinaryNotFound { path: binary });
         }
 
+        // Clean up stale lock files from ungraceful daemon termination.
+        Self::clean_stale_lock(config);
+
         if let Some(parent) = config.socket_path.parent()
             && !parent.as_os_str().is_empty()
         {
@@ -374,20 +398,13 @@ impl DaemonClient {
             std::fs::create_dir_all(runtime_data_dir)?;
         }
 
-        // Direct daemon stderr to a log file for `vz logs` support.
-        let log_file_path = config.socket_path.with_extension("log");
-        let stderr_target = std::fs::OpenOptions::new()
-            .create(true)
-            .append(true)
-            .open(&log_file_path)
-            .map(Stdio::from)
-            .unwrap_or_else(|_| Stdio::null());
-
+        // Daemon writes its own log file via tracing (next to the socket),
+        // so we can discard spawned process stdio.
         let mut command = Command::new(&binary);
         command
             .stdin(Stdio::null())
             .stdout(Stdio::null())
-            .stderr(stderr_target)
+            .stderr(Stdio::null())
             .arg("--socket-path")
             .arg(&config.socket_path);
 

crates/vz-runtimed/src/main.rs

@@ -41,9 +41,12 @@ struct Cli {
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    init_tracing();
     let cli = Cli::parse();
 
+    // Write logs to a file next to the socket for `vz logs` support.
+    let log_file_path = cli.socket_path.with_extension("log");
+    init_tracing(Some(&log_file_path));
+
     let daemon = Arc::new(
         RuntimeDaemon::start_with_checkpoint_retention_policy(
             RuntimedConfig {
@@ -87,8 +90,30 @@ async fn main() -> Result<()> {
     Ok(())
 }
 
-fn init_tracing() {
+fn init_tracing(log_file: Option<&std::path::Path>) {
     let env_filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+
+    if let Some(path) = log_file {
+        if let Some(parent) = path.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        if let Ok(file) = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(path)
+        {
+            tracing_subscriber::fmt()
+                .with_env_filter(env_filter)
+                .with_target(false)
+                .with_ansi(false)
+                .compact()
+                .with_writer(file)
+                .init();
+            return;
+        }
+    }
+
+    // Fallback: write to stderr (for interactive use / debugging).
     tracing_subscriber::fmt()
         .with_env_filter(env_filter)
         .with_target(false)