Method reload_vms

vmm/src/app.rs:545–621

(&self)

    }

    pub async fn reload_vms(&self) -> Result<()> {
        let vm_path = self.vm_dir();
        let running_vms = self.supervisor.list().await.context("Failed to list VMs")?;
        let running_vms: Vec<(ProcessAnnotation, _)> = running_vms
            .into_iter()
            .map(|p| (serde_json::from_str(&p.config.note).unwrap_or_default(), p))
            .collect();
        let occupied_cids = running_vms
            .iter()
            .filter(|(note, _)| note.is_cvm())
            .flat_map(|(_, p)| p.config.cid.map(|cid| (p.config.id.clone(), cid)))
            .collect::<HashMap<_, _>>();
        {
            let mut state = self.lock();
            for cid in occupied_cids.values() {
                state.cid_pool.occupy(*cid)?;
            }
        }

        // Track VMs with .removing marker — load them but resume cleanup
        let mut removing_ids = Vec::new();

        if vm_path.exists() {
            for entry in fs::read_dir(&vm_path).context("Failed to read VM directory")? {
                let entry = entry.context("Failed to read directory entry")?;
                let vm_path = entry.path();
                if vm_path.is_dir() {
                    let workdir = VmWorkDir::new(&vm_path);
                    let is_removing = workdir.is_removing();
                    // Load all VMs into memory (including removing ones, so they show in UI)
                    if let Err(err) = self.load_vm(&vm_path, &occupied_cids, !is_removing).await {
                        error!("Failed to load VM: {err:?}");
                    }
                    if is_removing {
                        if let Some(id) = vm_path.file_name().and_then(|n| n.to_str()) {
                            info!("Found VM {id} with .removing marker, resuming cleanup");
                            removing_ids.push(id.to_string());
                        }
                    }
                }
            }
        }

        // Resume cleanup for VMs with .removing marker
        for id in removing_ids {
            self.spawn_finish_remove(&id);
        }

        // Clean up orphaned supervisor processes (in supervisor but not loaded as VMs)
        let loaded_vm_ids: HashSet<String> = self.lock().vms.keys().cloned().collect();
        for (_, process) in &running_vms {
            if !loaded_vm_ids.contains(&process.config.id) {
                info!(
                    "Cleaning up orphaned supervisor process: {}",
                    process.config.id
                );
                self.spawn_finish_remove(&process.config.id);
            }