plugin-events: move model/find handlers to shared path

crates-cli/yaak-cli/src/context.rs

@@ -38,16 +38,12 @@ impl CliContext {
         let encryption_manager = Arc::new(EncryptionManager::new(query_manager.clone(), app_id));
 
         let plugin_manager = if with_plugins {
-            let embedded_vendored_plugin_dir = data_dir.join("vendored-plugins");
-            let bundled_plugin_dir =
-                resolve_bundled_plugin_dir_for_cli(&embedded_vendored_plugin_dir);
+            let vendored_plugin_dir = data_dir.join("vendored-plugins");
             let installed_plugin_dir = data_dir.join("installed-plugins");
             let node_bin_path = PathBuf::from("node");
 
-            if bundled_plugin_dir == embedded_vendored_plugin_dir {
-                prepare_embedded_vendored_plugins(&embedded_vendored_plugin_dir)
-                    .expect("Failed to prepare bundled plugins");
-            }
+            prepare_embedded_vendored_plugins(&vendored_plugin_dir)
+                .expect("Failed to prepare bundled plugins");
 
             let plugin_runtime_main =
                 std::env::var("YAAK_PLUGIN_RUNTIME").map(PathBuf::from).unwrap_or_else(|_| {
@@ -56,13 +52,13 @@ impl CliContext {
                 });
 
             match PluginManager::new(
-                bundled_plugin_dir,
-                embedded_vendored_plugin_dir,
+                vendored_plugin_dir,
                 installed_plugin_dir,
                 node_bin_path,
                 plugin_runtime_main,
                 &query_manager,
                 &PluginContext::new_empty(),
+                false,
             )
             .await
             {
@@ -135,20 +131,3 @@ fn prepare_embedded_vendored_plugins(vendored_plugin_dir: &Path) -> std::io::Res
     EMBEDDED_VENDORED_PLUGINS.extract(vendored_plugin_dir)?;
     Ok(())
 }
-
-fn resolve_bundled_plugin_dir_for_cli(embedded_vendored_plugin_dir: &Path) -> PathBuf {
-    if !cfg!(debug_assertions) {
-        return embedded_vendored_plugin_dir.to_path_buf();
-    }
-
-    let plugins_dir = match std::env::current_dir() {
-        Ok(cwd) => cwd.join("plugins"),
-        Err(_) => return embedded_vendored_plugin_dir.to_path_buf(),
-    };
-
-    if !plugins_dir.is_dir() {
-        return embedded_vendored_plugin_dir.to_path_buf();
-    }
-
-    plugins_dir.canonicalize().unwrap_or(plugins_dir)
-}

crates-tauri/yaak-app/src/plugin_events.rs

@@ -19,13 +19,13 @@ use yaak::plugin_events::{
     GroupedPluginEvent, HostRequest, SharedPluginEventContext, handle_shared_plugin_event,
 };
 use yaak_crypto::manager::EncryptionManager;
-use yaak_models::models::{AnyModel, HttpResponse, Plugin};
+use yaak_models::models::{HttpResponse, Plugin};
 use yaak_models::queries::any_request::AnyRequest;
 use yaak_models::util::UpdateSource;
 use yaak_plugins::error::Error::PluginErr;
 use yaak_plugins::events::{
-    Color, EmptyPayload, ErrorResponse, FindHttpResponsesResponse, GetCookieValueResponse, Icon,
-    InternalEvent, InternalEventPayload, ListCookieNamesResponse, ListOpenWorkspacesResponse,
+    Color, EmptyPayload, ErrorResponse, GetCookieValueResponse, Icon, InternalEvent,
+    InternalEventPayload, ListCookieNamesResponse, ListOpenWorkspacesResponse,
     RenderGrpcRequestResponse, RenderHttpRequestResponse, SendHttpRequestResponse,
     ShowToastRequest, TemplateRenderResponse, WindowInfoResponse, WindowNavigateEvent,
     WorkspaceInfo,
@@ -190,71 +190,6 @@ async fn handle_host_plugin_request<R: Runtime>(
                 Ok(None)
             }
         }
-        HostRequest::FindHttpResponses(req) => {
-            let http_responses = app_handle
-                .db()
-                .list_http_responses_for_request(&req.request_id, req.limit.map(|l| l as u64))
-                .unwrap_or_default();
-            Ok(Some(InternalEventPayload::FindHttpResponsesResponse(FindHttpResponsesResponse {
-                http_responses,
-            })))
-        }
-        HostRequest::UpsertModel(req) => {
-            use AnyModel::*;
-            let model = match &req.model {
-                HttpRequest(m) => {
-                    HttpRequest(app_handle.db().upsert_http_request(m, &UpdateSource::Plugin)?)
-                }
-                GrpcRequest(m) => {
-                    GrpcRequest(app_handle.db().upsert_grpc_request(m, &UpdateSource::Plugin)?)
-                }
-                WebsocketRequest(m) => WebsocketRequest(
-                    app_handle.db().upsert_websocket_request(m, &UpdateSource::Plugin)?,
-                ),
-                Folder(m) => Folder(app_handle.db().upsert_folder(m, &UpdateSource::Plugin)?),
-                Environment(m) => {
-                    Environment(app_handle.db().upsert_environment(m, &UpdateSource::Plugin)?)
-                }
-                Workspace(m) => {
-                    Workspace(app_handle.db().upsert_workspace(m, &UpdateSource::Plugin)?)
-                }
-                _ => {
-                    return Err(PluginErr("Upsert not supported for this model type".into()).into());
-                }
-            };
-
-            Ok(Some(InternalEventPayload::UpsertModelResponse(
-                yaak_plugins::events::UpsertModelResponse { model },
-            )))
-        }
-        HostRequest::DeleteModel(req) => {
-            let model = match req.model.as_str() {
-                "http_request" => AnyModel::HttpRequest(
-                    app_handle.db().delete_http_request_by_id(&req.id, &UpdateSource::Plugin)?,
-                ),
-                "grpc_request" => AnyModel::GrpcRequest(
-                    app_handle.db().delete_grpc_request_by_id(&req.id, &UpdateSource::Plugin)?,
-                ),
-                "websocket_request" => AnyModel::WebsocketRequest(
-                    app_handle
-                        .db()
-                        .delete_websocket_request_by_id(&req.id, &UpdateSource::Plugin)?,
-                ),
-                "folder" => AnyModel::Folder(
-                    app_handle.db().delete_folder_by_id(&req.id, &UpdateSource::Plugin)?,
-                ),
-                "environment" => AnyModel::Environment(
-                    app_handle.db().delete_environment_by_id(&req.id, &UpdateSource::Plugin)?,
-                ),
-                _ => {
-                    return Err(PluginErr("Delete not supported for this model type".into()).into());
-                }
-            };
-
-            Ok(Some(InternalEventPayload::DeleteModelResponse(
-                yaak_plugins::events::DeleteModelResponse { model },
-            )))
-        }
         HostRequest::RenderGrpcRequest(req) => {
             let window = get_window_from_plugin_context(app_handle, plugin_context)?;
 

crates-tauri/yaak-app/src/plugins_ext.rs

@@ -10,7 +10,6 @@ use crate::error::Result;
 use crate::models_ext::QueryManagerExt;
 use log::{error, info, warn};
 use serde::Serialize;
-use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::{Duration, Instant};
@@ -244,11 +243,6 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
                 .path()
                 .resolve("vendored/plugins", BaseDirectory::Resource)
                 .expect("failed to resolve plugin directory resource");
-            let bundled_plugin_dir = if is_dev() {
-                resolve_workspace_plugins_dir().unwrap_or_else(|| vendored_plugin_dir.clone())
-            } else {
-                vendored_plugin_dir.clone()
-            };
 
             let installed_plugin_dir = app_handle
                 .path()
@@ -272,6 +266,7 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
                 .expect("failed to resolve plugin runtime")
                 .join("index.cjs");
 
+            let dev_mode = is_dev();
             let query_manager =
                 app_handle.state::<yaak_models::query_manager::QueryManager>().inner().clone();
 
@@ -279,13 +274,13 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
             let app_handle_clone = app_handle.clone();
             tauri::async_runtime::block_on(async move {
                 let manager = PluginManager::new(
-                    bundled_plugin_dir,
                     vendored_plugin_dir,
                     installed_plugin_dir,
                     node_bin_path,
                     plugin_runtime_main,
                     &query_manager,
                     &PluginContext::new_empty(),
+                    dev_mode,
                 )
                 .await
                 .expect("Failed to initialize plugins");
@@ -327,11 +322,3 @@ pub fn init<R: Runtime>() -> TauriPlugin<R> {
         })
         .build()
 }
-
-fn resolve_workspace_plugins_dir() -> Option<PathBuf> {
-    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-        .join("../..")
-        .join("plugins")
-        .canonicalize()
-        .ok()
-}

crates/yaak-plugins/src/manager.rs

@@ -24,6 +24,7 @@ use crate::plugin_handle::PluginHandle;
 use crate::server_ws::PluginRuntimeServerWebsocket;
 use log::{error, info, warn};
 use std::collections::HashMap;
+use std::env;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
@@ -45,9 +46,9 @@ pub struct PluginManager {
     kill_tx: tokio::sync::watch::Sender<bool>,
     killed_rx: Arc<Mutex<Option<oneshot::Receiver<()>>>>,
     ws_service: Arc<PluginRuntimeServerWebsocket>,
-    bundled_plugin_dir: PathBuf,
     vendored_plugin_dir: PathBuf,
     pub(crate) installed_plugin_dir: PathBuf,
+    dev_mode: bool,
 }
 
 /// Callback for plugin initialization events (e.g., toast notifications)
@@ -57,21 +58,21 @@ impl PluginManager {
     /// Create a new PluginManager with the given paths.
     ///
     /// # Arguments
-    /// * `bundled_plugin_dir` - Directory to scan for bundled plugins
     /// * `vendored_plugin_dir` - Path to vendored plugins directory
     /// * `installed_plugin_dir` - Path to installed plugins directory
     /// * `node_bin_path` - Path to the yaaknode binary
     /// * `plugin_runtime_main` - Path to the plugin runtime index.cjs
     /// * `query_manager` - Query manager for bundled plugin registration and loading
     /// * `plugin_context` - Context to use while initializing plugins
+    /// * `dev_mode` - Whether the app is in dev mode (affects plugin loading)
     pub async fn new(
-        bundled_plugin_dir: PathBuf,
         vendored_plugin_dir: PathBuf,
         installed_plugin_dir: PathBuf,
         node_bin_path: PathBuf,
         plugin_runtime_main: PathBuf,
         query_manager: &QueryManager,
         plugin_context: &PluginContext,
+        dev_mode: bool,
     ) -> Result<PluginManager> {
         let (events_tx, mut events_rx) = mpsc::channel(2048);
         let (kill_server_tx, kill_server_rx) = tokio::sync::watch::channel(false);
@@ -88,9 +89,9 @@ impl PluginManager {
             ws_service: Arc::new(ws_service.clone()),
             kill_tx: kill_server_tx,
             killed_rx: Arc::new(Mutex::new(Some(killed_rx))),
-            bundled_plugin_dir,
             vendored_plugin_dir,
             installed_plugin_dir,
+            dev_mode,
         };
 
         // Forward events to subscribers
@@ -191,11 +192,25 @@ impl PluginManager {
         Ok(plugin_manager)
     }
 
+    /// Get the vendored plugin directory path (resolves dev mode path if applicable)
+    pub fn get_plugins_dir(&self) -> PathBuf {
+        if self.dev_mode {
+            // Use plugins directly for easy development
+            // Tauri runs from crates-tauri/yaak-app/, so go up two levels to reach project root
+            env::current_dir()
+                .map(|cwd| cwd.join("../../plugins").canonicalize().unwrap())
+                .unwrap_or_else(|_| self.vendored_plugin_dir.clone())
+        } else {
+            self.vendored_plugin_dir.clone()
+        }
+    }
+
     /// Read plugin directories from disk and return their paths.
     /// This is useful for discovering bundled plugins.
     pub async fn list_bundled_plugin_dirs(&self) -> Result<Vec<String>> {
-        info!("Loading bundled plugins from {:?}", self.bundled_plugin_dir);
-        read_plugins_dir(&self.bundled_plugin_dir).await
+        let plugins_dir = self.get_plugins_dir();
+        info!("Loading bundled plugins from {plugins_dir:?}");
+        read_plugins_dir(&plugins_dir).await
     }
 
     pub async fn uninstall(&self, plugin_context: &PluginContext, dir: &str) -> Result<()> {

crates/yaak/src/plugin_events.rs

@@ -1,14 +1,16 @@
+use yaak_models::models::AnyModel;
 use yaak_models::query_manager::QueryManager;
+use yaak_models::util::UpdateSource;
 use yaak_plugins::events::{
     CloseWindowRequest, CopyTextRequest, DeleteKeyValueRequest, DeleteKeyValueResponse,
-    DeleteModelRequest, ErrorResponse, FindHttpResponsesRequest, GetCookieValueRequest,
-    GetHttpRequestByIdRequest, GetHttpRequestByIdResponse, GetKeyValueRequest, GetKeyValueResponse,
-    InternalEventPayload, ListCookieNamesRequest, ListFoldersRequest, ListFoldersResponse,
-    ListHttpRequestsRequest, ListHttpRequestsResponse, ListOpenWorkspacesRequest,
-    OpenExternalUrlRequest, OpenWindowRequest, PromptFormRequest, PromptTextRequest,
-    ReloadResponse, RenderGrpcRequestRequest, RenderHttpRequestRequest, SendHttpRequestRequest,
-    SetKeyValueRequest, ShowToastRequest, TemplateRenderRequest, UpsertModelRequest,
-    WindowInfoRequest,
+    DeleteModelRequest, DeleteModelResponse, ErrorResponse, FindHttpResponsesRequest,
+    FindHttpResponsesResponse, GetCookieValueRequest, GetHttpRequestByIdRequest,
+    GetHttpRequestByIdResponse, GetKeyValueRequest, GetKeyValueResponse, InternalEventPayload,
+    ListCookieNamesRequest, ListFoldersRequest, ListFoldersResponse, ListHttpRequestsRequest,
+    ListHttpRequestsResponse, ListOpenWorkspacesRequest, OpenExternalUrlRequest, OpenWindowRequest,
+    PromptFormRequest, PromptTextRequest, ReloadResponse, RenderGrpcRequestRequest,
+    RenderHttpRequestRequest, SendHttpRequestRequest, SetKeyValueRequest, ShowToastRequest,
+    TemplateRenderRequest, UpsertModelRequest, UpsertModelResponse, WindowInfoRequest,
 };
 
 pub struct SharedPluginEventContext<'a> {
@@ -37,6 +39,9 @@ pub enum SharedRequest<'a> {
     GetHttpRequestById(&'a GetHttpRequestByIdRequest),
     ListFolders(&'a ListFoldersRequest),
     ListHttpRequests(&'a ListHttpRequestsRequest),
+    FindHttpResponses(&'a FindHttpResponsesRequest),
+    UpsertModel(&'a UpsertModelRequest),
+    DeleteModel(&'a DeleteModelRequest),
 }
 
 #[derive(Debug)]
@@ -45,9 +50,6 @@ pub enum HostRequest<'a> {
     CopyText(&'a CopyTextRequest),
     PromptText(&'a PromptTextRequest),
     PromptForm(&'a PromptFormRequest),
-    FindHttpResponses(&'a FindHttpResponsesRequest),
-    UpsertModel(&'a UpsertModelRequest),
-    DeleteModel(&'a DeleteModelRequest),
     RenderGrpcRequest(&'a RenderGrpcRequestRequest),
     RenderHttpRequest(&'a RenderHttpRequestRequest),
     TemplateRender(&'a TemplateRenderRequest),
@@ -71,9 +73,6 @@ impl HostRequest<'_> {
             HostRequest::CopyText(_) => "copy_text_request".to_string(),
             HostRequest::PromptText(_) => "prompt_text_request".to_string(),
             HostRequest::PromptForm(_) => "prompt_form_request".to_string(),
-            HostRequest::FindHttpResponses(_) => "find_http_responses_request".to_string(),
-            HostRequest::UpsertModel(_) => "upsert_model_request".to_string(),
-            HostRequest::DeleteModel(_) => "delete_model_request".to_string(),
             HostRequest::RenderGrpcRequest(_) => "render_grpc_request_request".to_string(),
             HostRequest::RenderHttpRequest(_) => "render_http_request_request".to_string(),
             HostRequest::TemplateRender(_) => "template_render_request".to_string(),
@@ -135,13 +134,13 @@ impl<'a> From<&'a InternalEventPayload> for GroupedPluginRequest<'a> {
                 GroupedPluginRequest::Host(HostRequest::PromptForm(req))
             }
             InternalEventPayload::FindHttpResponsesRequest(req) => {
-                GroupedPluginRequest::Host(HostRequest::FindHttpResponses(req))
+                GroupedPluginRequest::Shared(SharedRequest::FindHttpResponses(req))
             }
             InternalEventPayload::UpsertModelRequest(req) => {
-                GroupedPluginRequest::Host(HostRequest::UpsertModel(req))
+                GroupedPluginRequest::Shared(SharedRequest::UpsertModel(req))
             }
             InternalEventPayload::DeleteModelRequest(req) => {
-                GroupedPluginRequest::Host(HostRequest::DeleteModel(req))
+                GroupedPluginRequest::Shared(SharedRequest::DeleteModel(req))
             }
             InternalEventPayload::RenderGrpcRequestRequest(req) => {
                 GroupedPluginRequest::Host(HostRequest::RenderGrpcRequest(req))
@@ -275,17 +274,175 @@ fn build_shared_reply(
                 http_requests,
             })
         }
+        SharedRequest::FindHttpResponses(req) => {
+            let http_responses = query_manager
+                .connect()
+                .list_http_responses_for_request(&req.request_id, req.limit.map(|l| l as u64))
+                .unwrap_or_default();
+            InternalEventPayload::FindHttpResponsesResponse(FindHttpResponsesResponse {
+                http_responses,
+            })
+        }
+        SharedRequest::UpsertModel(req) => {
+            use AnyModel::*;
+
+            let model = match &req.model {
+                HttpRequest(m) => {
+                    match query_manager.connect().upsert_http_request(m, &UpdateSource::Plugin) {
+                        Ok(model) => HttpRequest(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to upsert HTTP request: {err}"),
+                            });
+                        }
+                    }
+                }
+                GrpcRequest(m) => {
+                    match query_manager.connect().upsert_grpc_request(m, &UpdateSource::Plugin) {
+                        Ok(model) => GrpcRequest(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to upsert gRPC request: {err}"),
+                            });
+                        }
+                    }
+                }
+                WebsocketRequest(m) => {
+                    match query_manager.connect().upsert_websocket_request(m, &UpdateSource::Plugin)
+                    {
+                        Ok(model) => WebsocketRequest(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to upsert WebSocket request: {err}"),
+                            });
+                        }
+                    }
+                }
+                Folder(m) => {
+                    match query_manager.connect().upsert_folder(m, &UpdateSource::Plugin) {
+                        Ok(model) => Folder(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to upsert folder: {err}"),
+                            });
+                        }
+                    }
+                }
+                Environment(m) => {
+                    match query_manager.connect().upsert_environment(m, &UpdateSource::Plugin) {
+                        Ok(model) => Environment(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to upsert environment: {err}"),
+                            });
+                        }
+                    }
+                }
+                Workspace(m) => {
+                    match query_manager.connect().upsert_workspace(m, &UpdateSource::Plugin) {
+                        Ok(model) => Workspace(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to upsert workspace: {err}"),
+                            });
+                        }
+                    }
+                }
+                _ => {
+                    return InternalEventPayload::ErrorResponse(ErrorResponse {
+                        error: "Upsert not supported for this model type".to_string(),
+                    });
+                }
+            };
+
+            InternalEventPayload::UpsertModelResponse(UpsertModelResponse { model })
+        }
+        SharedRequest::DeleteModel(req) => {
+            let model = match req.model.as_str() {
+                "http_request" => {
+                    match query_manager
+                        .connect()
+                        .delete_http_request_by_id(&req.id, &UpdateSource::Plugin)
+                    {
+                        Ok(model) => AnyModel::HttpRequest(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to delete HTTP request: {err}"),
+                            });
+                        }
+                    }
+                }
+                "grpc_request" => {
+                    match query_manager
+                        .connect()
+                        .delete_grpc_request_by_id(&req.id, &UpdateSource::Plugin)
+                    {
+                        Ok(model) => AnyModel::GrpcRequest(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to delete gRPC request: {err}"),
+                            });
+                        }
+                    }
+                }
+                "websocket_request" => {
+                    match query_manager
+                        .connect()
+                        .delete_websocket_request_by_id(&req.id, &UpdateSource::Plugin)
+                    {
+                        Ok(model) => AnyModel::WebsocketRequest(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to delete WebSocket request: {err}"),
+                            });
+                        }
+                    }
+                }
+                "folder" => match query_manager
+                    .connect()
+                    .delete_folder_by_id(&req.id, &UpdateSource::Plugin)
+                {
+                    Ok(model) => AnyModel::Folder(model),
+                    Err(err) => {
+                        return InternalEventPayload::ErrorResponse(ErrorResponse {
+                            error: format!("Failed to delete folder: {err}"),
+                        });
+                    }
+                },
+                "environment" => {
+                    match query_manager
+                        .connect()
+                        .delete_environment_by_id(&req.id, &UpdateSource::Plugin)
+                    {
+                        Ok(model) => AnyModel::Environment(model),
+                        Err(err) => {
+                            return InternalEventPayload::ErrorResponse(ErrorResponse {
+                                error: format!("Failed to delete environment: {err}"),
+                            });
+                        }
+                    }
+                }
+                _ => {
+                    return InternalEventPayload::ErrorResponse(ErrorResponse {
+                        error: "Delete not supported for this model type".to_string(),
+                    });
+                }
+            };
+
+            InternalEventPayload::DeleteModelResponse(DeleteModelResponse { model })
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use yaak_models::models::{Folder, HttpRequest, Workspace};
+    use tempfile::TempDir;
+    use yaak_models::models::{AnyModel, Folder, HttpRequest, Workspace};
     use yaak_models::util::UpdateSource;
 
-    fn seed_query_manager() -> QueryManager {
-        let temp_dir = tempfile::TempDir::new().expect("Failed to create temp dir");
+    fn seed_query_manager() -> (QueryManager, TempDir) {
+        let temp_dir = TempDir::new().expect("Failed to create temp dir");
         let db_path = temp_dir.path().join("db.sqlite");
         let blob_path = temp_dir.path().join("blobs.sqlite");
         let (query_manager, _blob_manager, _rx) =
@@ -332,12 +489,12 @@ mod tests {
             )
             .expect("Failed to seed request");
 
-        query_manager
+        (query_manager, temp_dir)
     }
 
     #[test]
     fn list_requests_requires_workspace_when_folder_missing() {
-        let query_manager = seed_query_manager();
+        let (query_manager, _temp_dir) = seed_query_manager();
         let payload = InternalEventPayload::ListHttpRequestsRequest(
             yaak_plugins::events::ListHttpRequestsRequest { folder_id: None },
         );
@@ -355,7 +512,7 @@ mod tests {
 
     #[test]
     fn list_requests_by_workspace_and_folder() {
-        let query_manager = seed_query_manager();
+        let (query_manager, _temp_dir) = seed_query_manager();
 
         let by_workspace_payload = InternalEventPayload::ListHttpRequestsRequest(
             yaak_plugins::events::ListHttpRequestsRequest { folder_id: None },
@@ -394,9 +551,83 @@ mod tests {
         }
     }
 
+    #[test]
+    fn find_http_responses_is_shared_handled() {
+        let (query_manager, _temp_dir) = seed_query_manager();
+        let payload = InternalEventPayload::FindHttpResponsesRequest(FindHttpResponsesRequest {
+            request_id: "rq_test".to_string(),
+            limit: Some(1),
+        });
+
+        let result = handle_shared_plugin_event(
+            &query_manager,
+            &payload,
+            SharedPluginEventContext { plugin_name: "@yaak/test", workspace_id: Some("wk_test") },
+        );
+
+        match result {
+            GroupedPluginEvent::Handled(Some(InternalEventPayload::FindHttpResponsesResponse(
+                resp,
+            ))) => {
+                assert!(resp.http_responses.is_empty());
+            }
+            other => panic!("unexpected find responses result: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn upsert_and_delete_model_are_shared_handled() {
+        let (query_manager, _temp_dir) = seed_query_manager();
+
+        let existing = query_manager
+            .connect()
+            .get_http_request("rq_test")
+            .expect("Failed to load seeded request");
+        let upsert_payload = InternalEventPayload::UpsertModelRequest(UpsertModelRequest {
+            model: AnyModel::HttpRequest(HttpRequest {
+                name: "Request Updated".to_string(),
+                ..existing
+            }),
+        });
+
+        let upsert_result = handle_shared_plugin_event(
+            &query_manager,
+            &upsert_payload,
+            SharedPluginEventContext { plugin_name: "@yaak/test", workspace_id: Some("wk_test") },
+        );
+        match upsert_result {
+            GroupedPluginEvent::Handled(Some(InternalEventPayload::UpsertModelResponse(resp))) => {
+                match resp.model {
+                    AnyModel::HttpRequest(r) => assert_eq!(r.name, "Request Updated"),
+                    other => panic!("unexpected upsert model type: {other:?}"),
+                }
+            }
+            other => panic!("unexpected upsert result: {other:?}"),
+        }
+
+        let delete_payload = InternalEventPayload::DeleteModelRequest(DeleteModelRequest {
+            model: "http_request".to_string(),
+            id: "rq_test".to_string(),
+        });
+        let delete_result = handle_shared_plugin_event(
+            &query_manager,
+            &delete_payload,
+            SharedPluginEventContext { plugin_name: "@yaak/test", workspace_id: Some("wk_test") },
+        );
+        match delete_result {
+            GroupedPluginEvent::Handled(Some(InternalEventPayload::DeleteModelResponse(resp))) => {
+                match resp.model {
+                    AnyModel::HttpRequest(r) => assert_eq!(r.id, "rq_test"),
+                    other => panic!("unexpected delete model type: {other:?}"),
+                }
+            }
+            other => panic!("unexpected delete result: {other:?}"),
+        }
+    }
+
     #[test]
     fn host_request_classification_works() {
-        let query_manager = seed_query_manager();
+        let (query_manager, _temp_dir) = seed_query_manager();
         let payload = InternalEventPayload::WindowInfoRequest(WindowInfoRequest {
             label: "main".to_string(),
         });