fix: add missing cleanup and timeouts

Signed-off-by: Bailey Hayes <behayes2@gmail.com>

Author: ricochet

crates/wash-runtime/src/engine/workload.rs

@@ -5,10 +5,11 @@ use std::{
     ops::{Deref, DerefMut},
     path::PathBuf,
     sync::Arc,
+    time::Duration,
 };
 
 use anyhow::{Context as _, bail, ensure};
-use tokio::{sync::RwLock, task::JoinHandle};
+use tokio::{sync::RwLock, task::JoinHandle, time::timeout};
 use tracing::{debug, info, trace, warn};
 use wasmtime::component::{
     Component, Instance, InstancePre, Linker, ResourceAny, ResourceType, Val, types::ComponentItem,
@@ -674,14 +675,22 @@ impl ResolvedWorkload {
 
                                                 let mut results_buf =
                                                     vec![Val::Bool(false); results.len()];
-                                                // TODO(IMPORTANT): Enforce a timeout on this call
-                                                // to prevent hanging indefinitely.
-                                                func.call_async(
-                                                    &mut store,
-                                                    &params_buf,
-                                                    &mut results_buf,
+
+                                                // Enforce a timeout on this call to prevent hanging indefinitely
+                                                const CALL_TIMEOUT: Duration =
+                                                    Duration::from_secs(30);
+                                                timeout(
+                                                    CALL_TIMEOUT,
+                                                    func.call_async(
+                                                        &mut store,
+                                                        &params_buf,
+                                                        &mut results_buf,
+                                                    ),
                                                 )
                                                 .await
+                                                .context(
+                                                    "function call timed out after 30 seconds",
+                                                )?
                                                 .context("failed to call function")?;
 
                                                 trace!(

src/main.rs

@@ -249,10 +249,24 @@ async fn main() {
     }
 
     // Since some interactive commands may hide the cursor, we need to ensure it is shown again on exit
+    // Clone the host Arc to move into the ctrl-c handler
+    let host_for_handler = ctx.host().clone();
     if let Err(e) = ctrlc::set_handler(move || {
         let term = dialoguer::console::Term::stdout();
         let _ = term.show_cursor();
-        // TODO(IMPORTANT): If the runtime is executing a component here, we need to stop it.
+
+        // Stop all running workloads and the host runtime
+        // Note: Signal handlers run outside the normal runtime context,
+        // so block_on is safe here and won't deadlock
+        if let Ok(handle) = tokio::runtime::Handle::try_current() {
+            let host = host_for_handler.clone();
+            if let Err(e) = handle.block_on(async move { host.stop().await }) {
+                eprintln!("Error stopping host: {e:?}");
+            }
+        }
+
+        // Exit with standard SIGINT code (128 + 2)
+        std::process::exit(130);
     }) {
         warn!(err = ?e, "failed to set ctrl_c handler, interactive prompts may not restore cursor visibility");
     }