tests(cli): prevent request send test teardown hang (#408)

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-cli/yaak-cli/tests/common/http_server.rs

@@ -1,9 +1,14 @@
 use std::io::{Read, Write};
-use std::net::TcpListener;
+use std::net::{SocketAddr, TcpListener, TcpStream};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
+use std::time::Duration;
 
 pub struct TestHttpServer {
     pub url: String,
+    addr: SocketAddr,
+    shutdown: Arc<AtomicBool>,
     handle: Option<thread::JoinHandle<()>>,
 }
 
@@ -12,29 +17,46 @@ impl TestHttpServer {
         let listener = TcpListener::bind("127.0.0.1:0").expect("Failed to bind test HTTP server");
         let addr = listener.local_addr().expect("Failed to get local addr");
         let url = format!("http://{addr}/test");
+        listener.set_nonblocking(true).expect("Failed to set test server listener nonblocking");
+
+        let shutdown = Arc::new(AtomicBool::new(false));
+        let shutdown_signal = Arc::clone(&shutdown);
         let body_bytes = body.as_bytes().to_vec();
 
         let handle = thread::spawn(move || {
-            if let Ok((mut stream, _)) = listener.accept() {
-                let mut request_buf = [0u8; 4096];
-                let _ = stream.read(&mut request_buf);
+            while !shutdown_signal.load(Ordering::Relaxed) {
+                match listener.accept() {
+                    Ok((mut stream, _)) => {
+                        let _ = stream.set_read_timeout(Some(Duration::from_secs(1)));
+                        let mut request_buf = [0u8; 4096];
+                        let _ = stream.read(&mut request_buf);
 
-                let response = format!(
-                    "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
-                    body_bytes.len()
-                );
-                let _ = stream.write_all(response.as_bytes());
-                let _ = stream.write_all(&body_bytes);
-                let _ = stream.flush();
+                        let response = format!(
+                            "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
+                            body_bytes.len()
+                        );
+                        let _ = stream.write_all(response.as_bytes());
+                        let _ = stream.write_all(&body_bytes);
+                        let _ = stream.flush();
+                        break;
+                    }
+                    Err(err) if err.kind() == std::io::ErrorKind::WouldBlock => {
+                        thread::sleep(Duration::from_millis(10));
+                    }
+                    Err(_) => break,
+                }
             }
         });
 
-        Self { url, handle: Some(handle) }
+        Self { url, addr, shutdown, handle: Some(handle) }
     }
 }
 
 impl Drop for TestHttpServer {
     fn drop(&mut self) {
+        self.shutdown.store(true, Ordering::Relaxed);
+        let _ = TcpStream::connect(self.addr);
+
         if let Some(handle) = self.handle.take() {
             let _ = handle.join();
         }

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-templates/pkg/yaak_templates.d.ts

@@ -1,5 +1,5 @@
 /* tslint:disable */
 /* eslint-disable */
-export function unescape_template(template: string): any;
-export function parse_template(template: string): any;
 export function escape_template(template: string): any;
+export function parse_template(template: string): any;
+export function unescape_template(template: string): any;

crates/yaak-templates/pkg/yaak_templates_bg.js

@@ -165,10 +165,10 @@ function takeFromExternrefTable0(idx) {
  * @param {string} template
  * @returns {any}
  */
-export function unescape_template(template) {
+export function escape_template(template) {
     const ptr0 = passStringToWasm0(template, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.unescape_template(ptr0, len0);
+    const ret = wasm.escape_template(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -193,10 +193,10 @@ export function parse_template(template) {
  * @param {string} template
  * @returns {any}
  */
-export function escape_template(template) {
+export function unescape_template(template) {
     const ptr0 = passStringToWasm0(template, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.escape_template(ptr0, len0);
+    const ret = wasm.unescape_template(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }