feat(pluginlab): safely share repl_vars behind Arc<Mutex<T>> between WasiState and PluginHost

PluginHost needs to have access to repl_vars now that there is
plugin-api/host-state-plugin#get-repl-var in wit.

Use Arc<Mutex<T>> instead of direct references to satisfy Send trait
requirements for async WebAssembly operations. While the runtime is
single-threaded, Wasmtime's async bindings require Send + Sync types.

Author: topheman

crates/pluginlab/src/engine.rs

@@ -1,7 +1,7 @@
 use crate::cli::Cli;
 use crate::permissions::NetworkPermissions;
 use anyhow::Result;
-use std::collections::HashMap;
+
 use std::path::Path;
 use wasmtime::component::{Component, Linker as ComponentLinker, ResourceTable};
 use wasmtime::{Config, Engine, Store};
@@ -120,15 +120,19 @@ impl WasmEngine {
 
     /// Create a new store with WASI context
     pub fn create_store(&self, wasi_ctx: WasiCtx, cli: &Cli) -> Store<WasiState> {
+        let repl_vars =
+            std::sync::Arc::new(std::sync::Mutex::new(std::collections::HashMap::new()));
+
         Store::new(
             &self.engine,
             WasiState {
                 ctx: wasi_ctx,
                 table: ResourceTable::new(),
                 plugin_host: PluginHost {
                     network_permissions: NetworkPermissions::from(cli),
+                    repl_vars: repl_vars.clone(),
                 },
-                repl_vars: HashMap::new(),
+                repl_vars,
                 plugins_names: Vec::new(),
             },
         )

crates/pluginlab/src/helpers.rs

@@ -1,22 +1,32 @@
 use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
 
 /// Handles setting exit status codes in REPL variables
 pub struct StatusHandler;
 
 impl StatusHandler {
     /// Set the exit status in the REPL variables
-    pub fn set_exit_status(repl_vars: &mut HashMap<String, String>, success: bool) {
+    pub fn set_exit_status(repl_vars: &mut Arc<Mutex<HashMap<String, String>>>, success: bool) {
         let status = if success { "0" } else { "1" };
-        repl_vars.insert("?".to_string(), status.to_string());
+        repl_vars
+            .lock()
+            .expect("Failed to acquire repl_vars lock")
+            .insert("?".to_string(), status.to_string());
     }
 }
 
 pub struct StdoutHandler;
 
 impl StdoutHandler {
-    pub fn print_and_set_last_result(repl_vars: &mut HashMap<String, String>, result: String) {
+    pub fn print_and_set_last_result(
+        repl_vars: &mut Arc<Mutex<HashMap<String, String>>>,
+        result: String,
+    ) {
         println!("{}", result);
-        repl_vars.insert("0".to_string(), result);
+        repl_vars
+            .lock()
+            .expect("Failed to acquire repl_vars lock")
+            .insert("0".to_string(), result);
     }
 }
 

crates/pluginlab/src/lib.rs

@@ -57,22 +57,33 @@ pub async fn run_async() -> Result<()> {
         eprintln!("[Host][Debug] Loaded plugins config: {:?}", plugins_config);
     }
 
-    host.store
-        .data_mut()
-        .repl_vars
-        .insert("ROOT".to_string(), "/Users".to_string());
-    host.store
-        .data_mut()
-        .repl_vars
-        .insert("USER".to_string(), "Tophe".to_string());
-    host.store
-        .data_mut()
-        .repl_vars
-        .insert("?".to_string(), "0".to_string());
+    {
+        let mut repl_vars = host
+            .store
+            .data_mut()
+            .repl_vars
+            .lock()
+            .expect("Failed to acquire repl_vars lock");
+        repl_vars.insert("ROOT".to_string(), "/Users".to_string());
+    }
+    {
+        let mut repl_vars = host
+            .store
+            .data_mut()
+            .repl_vars
+            .lock()
+            .expect("Failed to acquire repl_vars lock");
+        repl_vars.insert("USER".to_string(), "Tophe".to_string());
+        repl_vars.insert("?".to_string(), "0".to_string());
+    }
     if debug {
         eprintln!(
             "[Host][Debug] Loaded env vars: {:?}",
-            host.store.data().repl_vars
+            host.store
+                .data()
+                .repl_vars
+                .lock()
+                .expect("Failed to acquire repl_vars lock")
         );
     }
 
@@ -82,7 +93,14 @@ pub async fn run_async() -> Result<()> {
 
     loop {
         let mut line = String::new();
-        match host.store.data().repl_vars.get("?") {
+        match host
+            .store
+            .data()
+            .repl_vars
+            .lock()
+            .expect("Failed to acquire repl_vars lock")
+            .get("?")
+        {
             Some(last_status) => {
                 print!("repl({})> ", last_status);
             }

crates/pluginlab/src/store.rs

@@ -1,5 +1,6 @@
 use crate::permissions::NetworkPermissions;
 use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
 use wasmtime::component::ResourceTable;
 use wasmtime_wasi::p2::{IoView, WasiCtx, WasiView};
 
@@ -30,7 +31,7 @@ pub struct WasiState {
     /// and shared with the guest via the Guest bindings
 
     /// Custom environment variables stored by the REPL
-    pub repl_vars: HashMap<String, String>,
+    pub repl_vars: Arc<Mutex<HashMap<String, String>>>,
 
     /// Names of the plugins loaded in the host
     pub plugins_names: Vec<String>,
@@ -40,6 +41,8 @@ pub struct WasiState {
 pub struct PluginHost {
     /// Network permissions
     pub network_permissions: NetworkPermissions,
+    /// Shared reference to repl_vars from WasiState
+    pub repl_vars: Arc<Mutex<HashMap<String, String>>>,
 }
 
 impl crate::api::plugin_api::repl::api::http_client::Host for PluginHost {
@@ -85,10 +88,11 @@ impl crate::api::plugin_api::repl::api::http_client::Host for PluginHost {
 ///
 impl crate::api::plugin_api::repl::api::host_state_plugin::Host for PluginHost {
     async fn get_repl_var(&mut self, key: String) -> Option<String> {
-        None
-        // Can't do the following because `PluginHost` does not have access to repl_vars
-        // we need to add a repl_vars field to PluginHost that points to the repl_vars field of WasiState
-        // self.repl_vars.get(&key).cloned()
+        self.repl_vars
+            .lock()
+            .expect("Failed to acquire repl_vars lock")
+            .get(&key)
+            .cloned()
     }
 }
 
@@ -140,6 +144,8 @@ impl crate::api::host_api::repl::api::host_state::Host for WasiState {
     {
         // Return the stored environment variables
         self.repl_vars
+            .lock()
+            .expect("Failed to acquire repl_vars lock")
             .iter()
             .map(
                 |(key, value)| crate::api::host_api::repl::api::transport::ReplVar {
@@ -152,6 +158,9 @@ impl crate::api::host_api::repl::api::host_state::Host for WasiState {
 
     async fn set_repl_var(&mut self, var: crate::api::host_api::repl::api::transport::ReplVar) {
         // Set a single environment variable
-        self.repl_vars.insert(var.key.clone(), var.value.clone());
+        self.repl_vars
+            .lock()
+            .expect("Failed to acquire repl_vars lock")
+            .insert(var.key.clone(), var.value.clone());
     }
 }