Always open new window when clicking current workspace:

https://feedback.yaak.app/p/dont-trigger-workspace-change-when-clicking-same-workspace

.github/workflows/sponsors.yml

@@ -0,0 +1,43 @@
+name: Generate Sponsors README
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: 30 15 * * 0-6
+permissions:
+  contents: write
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout 🛎️
+        uses: actions/checkout@v2
+
+      - name: Generate Sponsors
+        uses: JamesIves/github-sponsors-readme-action@v1
+        with:
+          token: ${{ secrets.SPONSORS_PAT }}
+          file: 'README.md'
+          maximum: 1999
+          template: '<a href="https://github.com/{{{ login }}}"><img src="{{{ avatarUrl }}}" width="50px" alt="User avatar: {{{ login }}}" /></a>&nbsp;&nbsp;'
+          active-only: false
+          include-private: true
+          marker: 'sponsors-base'
+
+      - name: Generate Sponsors
+        uses: JamesIves/github-sponsors-readme-action@v1
+        with:
+          token: ${{ secrets.SPONSORS_PAT }}
+          file: 'README.md'
+          minimum: 2000
+          template: '<a href="https://github.com/{{{ login }}}"><img src="{{{ avatarUrl }}}" width="80px" alt="User avatar: {{{ login }}}" /></a>&nbsp;&nbsp;'
+          active-only: false
+          include-private: true
+          marker: 'sponsors-premium'
+
+      # ⚠️ Note: You can use any deployment step here to automatically push the README
+      # changes back to your branch.
+      - name: Commit Changes
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+          branch: main
+          folder: '.'

README.md

@@ -1,32 +1,66 @@
-# Yaak API Client
+<p align="center">
+  <a href="https://github.com/JamesIves/github-sponsors-readme-action">
+    <img width="200px" src="https://github.com/mountain-loop/yaak/raw/main/src-tauri/icons/icon.png">
+  </a>
+</p>
 
-Yaak is a desktop API client for interacting with REST, GraphQL, Server Sent Events (SSE), WebSocket, and gRPC
-APIs. It's built using [Tauri](https://tauri.app), Rust, and ReactJS.
+<h1 align="center">
+  💫 Yaak ➟ Desktop API Client 💫
+</h1>
+
+<p align="center">
+    A fast, privacy-first API client for REST, GraphQL, SSE, WebSocket, and gRPC – built with Tauri, Rust, and React.
+</p>
+<p align="center">
+ Development is funded by community-purchased <a href="https://yaak.app/pricing">licenses</a>. You can also <a href="https://github.com/sponsors/gschier">become a sponsor</a> to have your logo appear below. 💖
+</p>
+<br>
+
+
+
+<p align="center">
+  <!-- sponsors-premium --><a href="https://github.com/MVST-Solutions"><img src="https:&#x2F;&#x2F;github.com&#x2F;MVST-Solutions.png" width="80px" alt="User avatar: MVST-Solutions" /></a>&nbsp;&nbsp;<a href="https://github.com/dharsanb"><img src="https:&#x2F;&#x2F;github.com&#x2F;dharsanb.png" width="80px" alt="User avatar: dharsanb" /></a>&nbsp;&nbsp;<a href="https://github.com/railwayapp"><img src="https:&#x2F;&#x2F;github.com&#x2F;railwayapp.png" width="80px" alt="User avatar: railwayapp" /></a>&nbsp;&nbsp;<a href="https://github.com/caseyamcl"><img src="https:&#x2F;&#x2F;github.com&#x2F;caseyamcl.png" width="80px" alt="User avatar: caseyamcl" /></a>&nbsp;&nbsp;<a href="https://github.com/andriyor"><img src="https:&#x2F;&#x2F;github.com&#x2F;andriyor.png" width="80px" alt="User avatar: andriyor" /></a>&nbsp;&nbsp;<a href="https://github.com/"><img src="https:&#x2F;&#x2F;raw.githubusercontent.com&#x2F;JamesIves&#x2F;github-sponsors-readme-action&#x2F;dev&#x2F;.github&#x2F;assets&#x2F;placeholder.png" width="80px" alt="User avatar: " /></a>&nbsp;&nbsp;<!-- sponsors-premium -->
+</p>
+<p align="center">
+  <!-- sponsors-base --><a href="https://github.com/seanwash"><img src="https:&#x2F;&#x2F;github.com&#x2F;seanwash.png" width="50px" alt="User avatar: seanwash" /></a>&nbsp;&nbsp;<a href="https://github.com/jerath"><img src="https:&#x2F;&#x2F;github.com&#x2F;jerath.png" width="50px" alt="User avatar: jerath" /></a>&nbsp;&nbsp;<a href="https://github.com/itsa-sh"><img src="https:&#x2F;&#x2F;github.com&#x2F;itsa-sh.png" width="50px" alt="User avatar: itsa-sh" /></a>&nbsp;&nbsp;<a href="https://github.com/dmmulroy"><img src="https:&#x2F;&#x2F;github.com&#x2F;dmmulroy.png" width="50px" alt="User avatar: dmmulroy" /></a>&nbsp;&nbsp;<a href="https://github.com/timcole"><img src="https:&#x2F;&#x2F;github.com&#x2F;timcole.png" width="50px" alt="User avatar: timcole" /></a>&nbsp;&nbsp;<a href="https://github.com/VLZH"><img src="https:&#x2F;&#x2F;github.com&#x2F;VLZH.png" width="50px" alt="User avatar: VLZH" /></a>&nbsp;&nbsp;<a href="https://github.com/terasaka2k"><img src="https:&#x2F;&#x2F;github.com&#x2F;terasaka2k.png" width="50px" alt="User avatar: terasaka2k" /></a>&nbsp;&nbsp;<!-- sponsors-base -->
+</p>
 
 ![Yaak API Client](https://yaak.app/static/screenshot.png)
 
+
+## Features
+
+Yaak is an offline-first API client designed to stay out of your way while giving you everything you need when you need it. 
+Built with [Tauri](https://tauri.app), Rust, and React, it’s fast, lightweight, and private. No telemetry, no VC funding, and no cloud lock-in.  
+
+
+### 🌐 Work with any API
+
+- Import collections from Postman, Insomnia, OpenAPI, Swagger, or Curl.
+- Send requests via REST, GraphQL, gRPC, WebSocket, or Server-Sent Events.
+- Filter and inspect responses with JSONPath or XPath.
+
+### 🔐 Stay secure
+- Use OAuth 2.0, JWT, Basic Auth, or custom plugins for authentication.
+- Secure sensitive values with end-to-end encryption.
+- Store secrets in your OS keychain.
+
+### ☁️ Organize & collaborate
+- Group requests into workspaces and nested folders.
+- Use environment variables to switch between dev, staging, and prod.
+- Mirror workspaces to your filesystem for versioning in Git or syncing with Dropbox.
+
+### 🧩 Extend & customize
+- Insert dynamic values like UUIDs or timestamps with template tags.
+- Pick from built-in themes or build your own.
+- Create plugins to extend authentication, template tags, or the UI.
+
+
 ## Contribution Policy
 
 Yaak is open source, but only accepting contributions for bug fixes. To get started, 
 visit [`DEVELOPMENT.md`](DEVELOPMENT.md) for tips on setting up your environment.
 
-## Feature Overview
-
-- 🪂 Import data from Postman, Insomnia, OpenAPI, Swagger, or Curl.<br/>
-- 📤 Send requests via REST, GraphQL, Server Sent Events (SSE), WebSockets, or gRPC.<br/>
-- 🔐 Automatically authorize requests with OAuth 2.0, JWT tokens, Basic Auth, and more.<br/>
-- 🔎 Filter response bodies using JSONPath or XPath queries.<br/>
-- ⛓️ Chain together multiple requests to dynamically reference values.<br/>
-- 📂 Organize requests into workspaces and nested folders.<br/>
-- 🧮 Use environment variables to easily switch between Prod and Dev.<br/>
-- 🛡️ Secure arbitrary text values with end-to-end encryption<br/>
-- 🏷️ Send dynamic values like UUIDs or timestamps using template tags.<br/>
-- 🎨 Choose from many of the included themes, or make your own.<br/>
-- 💽 Mirror workspace data to a directory for integration with Git or Dropbox.<br/>
-- 📜 View response history for each request.<br/>
-- 🔌 Create your own plugins for authentication, template tags, and more!<br/>
-- 🛜 Configure a proxy to access firewall-blocked APIs
-
 ## Useful Resources
 
 - [Feedback and Bug Reports](https://feedback.yaak.app)

plugins/importer-yaak/src/index.ts

@@ -68,11 +68,11 @@ export function migrateImport(contents: string) {
 
   // Migrate v4 to v5
   for (const environment of parsed.resources.environments ?? []) {
-    if ('base' in environment && environment.base) {
+    if ('base' in environment && environment.base && environment.parentModel == null) {
       environment.parentModel = 'workspace';
       environment.parentId = null;
       delete environment.base;
-    } else if ('base' in environment && !environment.base) {
+    } else if ('base' in environment && !environment.base && environment.parentModel == null) {
       environment.parentModel = 'environment';
       environment.parentId = null;
       delete environment.base;

src-tauri/Cargo.lock

@@ -8102,6 +8102,7 @@ name = "yaak-templates"
 version = "0.1.0"
 dependencies = [
  "base64 0.22.1",
+ "log",
  "serde",
  "serde-wasm-bindgen",
  "serde_json",

src-tauri/src/http_request.rs

@@ -32,6 +32,7 @@ use yaak_plugins::events::{
 };
 use yaak_plugins::manager::PluginManager;
 use yaak_plugins::template_callback::PluginTemplateCallback;
+use yaak_templates::{RenderErrorBehavior, RenderOptions};
 
 pub async fn send_http_request<R: Runtime>(
     window: &WebviewWindow<R>,
@@ -76,7 +77,11 @@ pub async fn send_http_request<R: Runtime>(
         RenderPurpose::Send,
     );
 
-    let request = match render_http_request(&resolved_request, environment_chain, &cb).await {
+    let opt = RenderOptions {
+        error_behavior: RenderErrorBehavior::Throw,
+    };
+
+    let request = match render_http_request(&resolved_request, environment_chain, &cb, &opt).await {
         Ok(r) => r,
         Err(e) => {
             return Ok(response_err(

src-tauri/src/lib.rs

@@ -49,7 +49,7 @@ use yaak_plugins::plugin_meta::PluginMetadata;
 use yaak_plugins::template_callback::PluginTemplateCallback;
 use yaak_sse::sse::ServerSentEvent;
 use yaak_templates::format::format_json;
-use yaak_templates::{Tokens, transform_args};
+use yaak_templates::{Tokens, transform_args, RenderOptions, RenderErrorBehavior};
 
 mod commands;
 mod encoding;
@@ -126,6 +126,9 @@ async fn cmd_render_template<R: Runtime>(
             &PluginWindowContext::new(&window),
             RenderPurpose::Preview,
         ),
+        &RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        },
     )
     .await?;
     Ok(result)
@@ -167,6 +170,9 @@ async fn cmd_grpc_reflect<R: Runtime>(
             &PluginWindowContext::new(&window),
             RenderPurpose::Send,
         ),
+        &RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        },
     )
     .await?;
 
@@ -213,6 +219,9 @@ async fn cmd_grpc_go<R: Runtime>(
             &PluginWindowContext::new(&window),
             RenderPurpose::Send,
         ),
+        &RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        },
     )
     .await?;
 
@@ -335,6 +344,9 @@ async fn cmd_grpc_go<R: Runtime>(
                                     &PluginWindowContext::new(&window),
                                     RenderPurpose::Send,
                                 ),
+                                &RenderOptions {
+                                    error_behavior: RenderErrorBehavior::Throw,
+                                },
                             )
                             .await
                             .expect("Failed to render template")
@@ -404,6 +416,9 @@ async fn cmd_grpc_go<R: Runtime>(
                 &PluginWindowContext::new(&window),
                 RenderPurpose::Send,
             ),
+            &RenderOptions {
+                error_behavior: RenderErrorBehavior::Throw,
+            },
         )
         .await?;
 

src-tauri/src/plugin_events.rs

@@ -23,6 +23,7 @@ use yaak_plugins::events::{
 use yaak_plugins::manager::PluginManager;
 use yaak_plugins::plugin_handle::PluginHandle;
 use yaak_plugins::template_callback::PluginTemplateCallback;
+use yaak_templates::{RenderErrorBehavior, RenderOptions};
 
 pub(crate) async fn handle_plugin_event<R: Runtime>(
     app_handle: &AppHandle<R>,
@@ -80,7 +81,10 @@ pub(crate) async fn handle_plugin_event<R: Runtime>(
                 .resolve_environments(&workspace.id, None, environment_id.as_deref())
                 .expect("Failed to resolve environments");
             let cb = PluginTemplateCallback::new(app_handle, &window_context, req.purpose);
-            let grpc_request = render_grpc_request(&req.grpc_request, environment_chain, &cb)
+            let opt = RenderOptions {
+                error_behavior: RenderErrorBehavior::Throw,
+            };
+            let grpc_request = render_grpc_request(&req.grpc_request, environment_chain, &cb, &opt)
                 .await
                 .expect("Failed to render grpc request");
             Some(InternalEventPayload::RenderGrpcRequestResponse(RenderGrpcRequestResponse {
@@ -99,7 +103,10 @@ pub(crate) async fn handle_plugin_event<R: Runtime>(
                 .resolve_environments(&workspace.id, None, environment_id.as_deref())
                 .expect("Failed to resolve environments");
             let cb = PluginTemplateCallback::new(app_handle, &window_context, req.purpose);
-            let http_request = render_http_request(&req.http_request, environment_chain, &cb)
+            let opt = &RenderOptions {
+                error_behavior: RenderErrorBehavior::Throw,
+            };
+            let http_request = render_http_request(&req.http_request, environment_chain, &cb, &opt)
                 .await
                 .expect("Failed to render http request");
             Some(InternalEventPayload::RenderHttpRequestResponse(RenderHttpRequestResponse {
@@ -118,7 +125,10 @@ pub(crate) async fn handle_plugin_event<R: Runtime>(
                 .resolve_environments(&workspace.id, None, environment_id.as_deref())
                 .expect("Failed to resolve environments");
             let cb = PluginTemplateCallback::new(app_handle, &window_context, req.purpose);
-            let data = render_json_value(req.data, environment_chain, &cb)
+            let opt = RenderOptions {
+                error_behavior: RenderErrorBehavior::Throw,
+            };
+            let data = render_json_value(req.data, environment_chain, &cb, &opt)
                 .await
                 .expect("Failed to render template");
             Some(InternalEventPayload::TemplateRenderResponse(TemplateRenderResponse { data }))
@@ -163,6 +173,7 @@ pub(crate) async fn handle_plugin_event<R: Runtime>(
                     &InternalEventPayload::ShowToastRequest(ShowToastRequest {
                         message: format!("Reloaded plugin {}@{}", info.name, info.version),
                         icon: Some(Icon::Info),
+                        timeout: Some(3000),
                         ..Default::default()
                     }),
                     None,

src-tauri/src/render.rs

@@ -1,34 +1,37 @@
 use serde_json::Value;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 use yaak_http::apply_path_placeholders;
 use yaak_models::models::{
     Environment, GrpcRequest, HttpRequest, HttpRequestHeader, HttpUrlParameter,
 };
 use yaak_models::render::make_vars_hashmap;
-use yaak_templates::{TemplateCallback, parse_and_render, render_json_value_raw};
+use yaak_templates::{RenderOptions, TemplateCallback, parse_and_render, render_json_value_raw};
 
 pub async fn render_template<T: TemplateCallback>(
     template: &str,
     environment_chain: Vec<Environment>,
     cb: &T,
+    opt: &RenderOptions,
 ) -> yaak_templates::error::Result<String> {
     let vars = &make_vars_hashmap(environment_chain);
-    render(template, vars, cb).await
+    parse_and_render(template, vars, cb, &opt).await
 }
 
 pub async fn render_json_value<T: TemplateCallback>(
     value: Value,
     environment_chain: Vec<Environment>,
     cb: &T,
+    opt: &RenderOptions,
 ) -> yaak_templates::error::Result<Value> {
     let vars = &make_vars_hashmap(environment_chain);
-    render_json_value_raw(value, vars, cb).await
+    render_json_value_raw(value, vars, cb, opt).await
 }
 
 pub async fn render_grpc_request<T: TemplateCallback>(
     r: &GrpcRequest,
     environment_chain: Vec<Environment>,
     cb: &T,
+    opt: &RenderOptions,
 ) -> yaak_templates::error::Result<GrpcRequest> {
     let vars = &make_vars_hashmap(environment_chain);
 
@@ -36,18 +39,18 @@ pub async fn render_grpc_request<T: TemplateCallback>(
     for p in r.metadata.clone() {
         metadata.push(HttpRequestHeader {
             enabled: p.enabled,
-            name: render(p.name.as_str(), vars, cb).await?,
-            value: render(p.value.as_str(), vars, cb).await?,
+            name: parse_and_render(p.name.as_str(), vars, cb, &opt).await?,
+            value: parse_and_render(p.value.as_str(), vars, cb, &opt).await?,
             id: p.id,
         })
     }
 
     let mut authentication = BTreeMap::new();
     for (k, v) in r.authentication.clone() {
-        authentication.insert(k, render_json_value_raw(v, vars, cb).await?);
+        authentication.insert(k, render_json_value_raw(v, vars, cb, &opt).await?);
     }
 
-    let url = render(r.url.as_str(), vars, cb).await?;
+    let url = parse_and_render(r.url.as_str(), vars, cb, &opt).await?;
 
     Ok(GrpcRequest {
         url,
@@ -61,6 +64,7 @@ pub async fn render_http_request<T: TemplateCallback>(
     r: &HttpRequest,
     environment_chain: Vec<Environment>,
     cb: &T,
+    opt: &RenderOptions,
 ) -> yaak_templates::error::Result<HttpRequest> {
     let vars = &make_vars_hashmap(environment_chain);
 
@@ -68,8 +72,8 @@ pub async fn render_http_request<T: TemplateCallback>(
     for p in r.url_parameters.clone() {
         url_parameters.push(HttpUrlParameter {
             enabled: p.enabled,
-            name: render(p.name.as_str(), vars, cb).await?,
-            value: render(p.value.as_str(), vars, cb).await?,
+            name: parse_and_render(p.name.as_str(), vars, cb, &opt).await?,
+            value: parse_and_render(p.value.as_str(), vars, cb, &opt).await?,
             id: p.id,
         })
     }
@@ -78,23 +82,23 @@ pub async fn render_http_request<T: TemplateCallback>(
     for p in r.headers.clone() {
         headers.push(HttpRequestHeader {
             enabled: p.enabled,
-            name: render(p.name.as_str(), vars, cb).await?,
-            value: render(p.value.as_str(), vars, cb).await?,
+            name: parse_and_render(p.name.as_str(), vars, cb, &opt).await?,
+            value: parse_and_render(p.value.as_str(), vars, cb, &opt).await?,
             id: p.id,
         })
     }
 
     let mut body = BTreeMap::new();
     for (k, v) in r.body.clone() {
-        body.insert(k, render_json_value_raw(v, vars, cb).await?);
+        body.insert(k, render_json_value_raw(v, vars, cb, &opt).await?);
     }
 
     let mut authentication = BTreeMap::new();
     for (k, v) in r.authentication.clone() {
-        authentication.insert(k, render_json_value_raw(v, vars, cb).await?);
+        authentication.insert(k, render_json_value_raw(v, vars, cb, &opt).await?);
     }
 
-    let url = render(r.url.clone().as_str(), vars, cb).await?;
+    let url = parse_and_render(r.url.clone().as_str(), vars, cb, &opt).await?;
 
     // This doesn't fit perfectly with the concept of "rendering" but it kind of does
     let (url, url_parameters) = apply_path_placeholders(&url, url_parameters);
@@ -108,11 +112,3 @@ pub async fn render_http_request<T: TemplateCallback>(
         ..r.to_owned()
     })
 }
-
-pub async fn render<T: TemplateCallback>(
-    template: &str,
-    vars: &HashMap<String, String>,
-    cb: &T,
-) -> yaak_templates::error::Result<String> {
-    parse_and_render(template, vars, cb).await
-}

src-tauri/yaak-models/src/queries/batch.rs

@@ -49,15 +49,7 @@ impl<'a> DbContext<'a> {
             info!("Upserted {} websocket_requests", imported_resources.websocket_requests.len());
         }
 
-        if environments.len() > 0 {
-            for x in environments {
-                let x = self.upsert_environment(&x, source)?;
-                imported_resources.environments.push(x.clone());
-            }
-            info!("Upserted {} environments", imported_resources.environments.len());
-        }
-
-        // Do folders last so it doesn't cause the UI to render empty folders before populating
+        // Do folders after their children so the UI doesn't render empty folders before populating
         // immediately after.
         if folders.len() > 0 {
             for v in folders {
@@ -67,6 +59,15 @@ impl<'a> DbContext<'a> {
             info!("Upserted {} folders", imported_resources.folders.len());
         }
 
+        // Do environments last because they can depend on many models (requests, folders, etc)
+        if environments.len() > 0 {
+            for x in environments {
+                let x = self.upsert_environment(&x, source)?;
+                imported_resources.environments.push(x.clone());
+            }
+            info!("Upserted {} environments", imported_resources.environments.len());
+        }
+
         Ok(imported_resources)
     }
 }

src-tauri/yaak-models/src/queries/environments.rs

@@ -37,8 +37,7 @@ impl<'a> DbContext<'a> {
 
     /// Lists environments and will create a base environment if one doesn't exist
     pub fn list_environments_ensure_base(&self, workspace_id: &str) -> Result<Vec<Environment>> {
-        let mut environments =
-            self.find_many::<Environment>(EnvironmentIden::WorkspaceId, workspace_id, None)?;
+        let mut environments = self.list_environments_dangerous(workspace_id)?;
 
         let base_environment = environments.iter().find(|e| e.parent_model == "workspace");
 
@@ -59,6 +58,11 @@ impl<'a> DbContext<'a> {
         Ok(environments)
     }
 
+    /// List environments for a workspace. Prefer list_environments_ensure_base()
+    fn list_environments_dangerous(&self, workspace_id: &str) -> Result<Vec<Environment>> {
+        Ok(self.find_many::<Environment>(EnvironmentIden::WorkspaceId, workspace_id, None)?)
+    }
+
     pub fn delete_environment(
         &self,
         environment: &Environment,
@@ -93,7 +97,7 @@ impl<'a> DbContext<'a> {
             return Vec::new();
         }
 
-        self.list_environments_ensure_base(&environment.workspace_id)
+        self.list_environments_dangerous(&environment.workspace_id)
             .unwrap_or_default()
             .into_iter()
             .filter(|e| {
@@ -131,8 +135,9 @@ impl<'a> DbContext<'a> {
         let mut name = environment.name.clone();
         match (environment.parent_model.as_str(), environment.parent_id.as_deref()) {
             ("folder", Some(folder_id)) => {
-                let folder = self.get_folder(folder_id)?;
-                name = format!("{} Environment", folder.name);
+                if let Ok(folder) = self.get_folder(folder_id) {
+                    name = format!("{} Environment", folder.name);
+                }
             }
             _ => {}
         }

src-tauri/yaak-plugins/src/manager.rs

@@ -39,7 +39,7 @@ use yaak_models::render::make_vars_hashmap;
 use yaak_models::util::generate_id;
 use yaak_templates::error::Error::RenderError;
 use yaak_templates::error::Result as TemplateResult;
-use yaak_templates::render_json_value_raw;
+use yaak_templates::{RenderErrorBehavior, RenderOptions, render_json_value_raw};
 
 #[derive(Clone)]
 pub struct PluginManager {
@@ -601,7 +601,11 @@ impl PluginManager {
             &PluginWindowContext::new(&window),
             RenderPurpose::Preview,
         );
-        let rendered_values = render_json_value_raw(json!(values), vars, &cb).await?;
+        // We don't want to fail for this op because the UI will not be able to list any auth types then
+        let render_opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::ReturnEmpty,
+        };
+        let rendered_values = render_json_value_raw(json!(values), vars, &cb, &render_opt).await?;
         let context_id = format!("{:x}", md5::compute(request_id.to_string()));
         let event = self
             .send_to_plugin_and_wait(
@@ -643,6 +647,9 @@ impl PluginManager {
                 &PluginWindowContext::new(&window),
                 RenderPurpose::Preview,
             ),
+            &RenderOptions {
+                error_behavior: RenderErrorBehavior::Throw,
+            },
         )
         .await?;
         let results = self.get_http_authentication_summaries(window).await?;

src-tauri/yaak-sync/src/models.rs

@@ -1,7 +1,7 @@
 use crate::error::Error::UnknownModel;
 use crate::error::Result;
 use chrono::NaiveDateTime;
-use log::warn;
+use log::{debug, warn};
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_yaml::{Mapping, Value};
 use sha1::{Digest, Sha1};
@@ -84,8 +84,9 @@ impl<'de> Deserialize<'de> for SyncModel {
 }
 
 fn migrate_environment(obj: &mut Mapping) {
-    match obj.get("base") {
-        Some(Value::Bool(base)) => {
+    match (obj.get("base"), obj.get("parentModel")) {
+        (Some(Value::Bool(base)), None) => {
+            debug!("Migrating legacy environment {}", serde_yaml::to_string(obj).unwrap());
             if *base {
                 obj.insert("parentModel".into(), "workspace".into());
             } else {
@@ -220,7 +221,7 @@ impl TryFrom<AnyModel> for SyncModel {
 }
 
 #[cfg(test)]
-mod placeholder_tests {
+mod migration_tests {
     use crate::error::Result;
     use crate::models::SyncModel;
 
@@ -271,6 +272,30 @@ color: null
             _ => panic!("expected sub environment"),
         }
 
+        let raw = r#"
+type: environment
+model: environment
+id: ev_fAUS49FUN2
+parentId: fld_123
+parentModel: folder
+workspaceId: wk_kfSI3JDHd7
+createdAt: 2025-01-11T17:02:58.012792
+updatedAt: 2025-07-23T20:00:46.049649
+name: Folder Environment
+public: true
+base: false
+variables: []
+color: null
+"#;
+        let m: SyncModel = serde_yaml::from_str(raw)?;
+        match m {
+            SyncModel::Environment(env) => {
+                assert_eq!(env.parent_model, "folder".to_string());
+                assert_eq!(env.parent_id, Some("fld_123".to_string()));
+            }
+            _ => panic!("expected folder environment"),
+        }
+
         Ok(())
     }
 }

src-tauri/yaak-templates/Cargo.toml

@@ -19,3 +19,4 @@ tokio = { workspace = true, features = ["macros", "rt"] }
 ts-rs = { workspace = true }
 wasm-bindgen = { version = "0.2.100", features = ["serde-serialize"] }
 serde-wasm-bindgen = "0.6.5"
+log = "0.4.27"

src-tauri/yaak-templates/src/renderer.rs

@@ -1,6 +1,7 @@
 use crate::error::Error::{RenderStackExceededError, VariableNotFound};
 use crate::error::Result;
 use crate::{Parser, Token, Tokens, Val};
+use log::warn;
 use serde_json::json;
 use std::collections::HashMap;
 use std::future::Future;
@@ -21,21 +22,22 @@ pub async fn render_json_value_raw<T: TemplateCallback>(
     v: serde_json::Value,
     vars: &HashMap<String, String>,
     cb: &T,
+    opt: &RenderOptions,
 ) -> Result<serde_json::Value> {
     let v = match v {
-        serde_json::Value::String(s) => json!(parse_and_render(&s, vars, cb).await?),
+        serde_json::Value::String(s) => json!(parse_and_render(&s, vars, cb, opt).await?),
         serde_json::Value::Array(a) => {
             let mut new_a = Vec::new();
             for v in a {
-                new_a.push(Box::pin(render_json_value_raw(v, vars, cb)).await?)
+                new_a.push(Box::pin(render_json_value_raw(v, vars, cb, opt)).await?)
             }
             json!(new_a)
         }
         serde_json::Value::Object(o) => {
             let mut new_o = serde_json::Map::new();
             for (k, v) in o {
-                let key = Box::pin(parse_and_render(&k, vars, cb)).await?;
-                let value = Box::pin(render_json_value_raw(v, vars, cb)).await?;
+                let key = Box::pin(parse_and_render(&k, vars, cb, opt)).await?;
+                let value = Box::pin(render_json_value_raw(v, vars, cb, opt)).await?;
                 new_o.insert(key, value);
             }
             json!(new_o)
@@ -49,30 +51,55 @@ async fn parse_and_render_at_depth<T: TemplateCallback>(
     template: &str,
     vars: &HashMap<String, String>,
     cb: &T,
+    opt: &RenderOptions,
     depth: usize,
 ) -> Result<String> {
     let mut p = Parser::new(template);
     let tokens = p.parse()?;
-    render(tokens, vars, cb, depth + 1).await
+    render(tokens, vars, cb, opt, depth + 1).await
 }
 
 pub async fn parse_and_render<T: TemplateCallback>(
     template: &str,
     vars: &HashMap<String, String>,
     cb: &T,
+    opt: &RenderOptions,
 ) -> Result<String> {
-    parse_and_render_at_depth(template, vars, cb, 1).await
+    parse_and_render_at_depth(template, vars, cb, opt, 1).await
+}
+
+pub enum RenderErrorBehavior {
+    Throw,
+    ReturnEmpty,
+}
+
+pub struct RenderOptions {
+    pub error_behavior: RenderErrorBehavior,
+}
+
+impl RenderErrorBehavior {
+    pub fn handle(&self, r: Result<String>) -> Result<String> {
+        match (self, r) {
+            (_, Ok(v)) => Ok(v),
+            (RenderErrorBehavior::Throw, Err(e)) => Err(e),
+            (RenderErrorBehavior::ReturnEmpty, Err(e)) => {
+                warn!("Error rendering string: {}", e);
+                Ok("".to_string())
+            }
+        }
+    }
 }
 
 pub async fn render<T: TemplateCallback>(
     tokens: Tokens,
     vars: &HashMap<String, String>,
     cb: &T,
+    opt: &RenderOptions,
     mut depth: usize,
 ) -> Result<String> {
     depth += 1;
     if depth > MAX_DEPTH {
-        return Err(RenderStackExceededError);
+        return opt.error_behavior.handle(Err(RenderStackExceededError));
     }
 
     let mut doc_str: Vec<String> = Vec::new();
@@ -80,7 +107,10 @@ pub async fn render<T: TemplateCallback>(
     for t in tokens.tokens {
         match t {
             Token::Raw { text } => doc_str.push(text),
-            Token::Tag { val } => doc_str.push(render_value(val, &vars, cb, depth).await?),
+            Token::Tag { val } => {
+                let val = render_value(val, &vars, cb, opt, depth).await;
+                doc_str.push(opt.error_behavior.handle(val)?)
+            }
             Token::Eof => {}
         }
     }
@@ -92,16 +122,17 @@ async fn render_value<T: TemplateCallback>(
     val: Val,
     vars: &HashMap<String, String>,
     cb: &T,
+    opt: &RenderOptions,
     depth: usize,
 ) -> Result<String> {
     let v = match val {
         Val::Str { text } => {
-            let r = Box::pin(parse_and_render_at_depth(&text, vars, cb, depth)).await?;
+            let r = Box::pin(parse_and_render_at_depth(&text, vars, cb, opt, depth)).await?;
             r.to_string()
         }
         Val::Var { name } => match vars.get(name.as_str()) {
             Some(v) => {
-                let r = Box::pin(parse_and_render_at_depth(v, vars, cb, depth)).await?;
+                let r = Box::pin(parse_and_render_at_depth(v, vars, cb, opt, depth)).await?;
                 r.to_string()
             }
             None => return Err(VariableNotFound(name)),
@@ -113,13 +144,13 @@ async fn render_value<T: TemplateCallback>(
                     Val::Bool { value } => serde_json::Value::Bool(value),
                     Val::Null => serde_json::Value::Null,
                     _ => serde_json::Value::String(
-                        Box::pin(render_value(a.value, vars, cb, depth)).await?,
+                        Box::pin(render_value(a.value, vars, cb, opt, depth)).await?,
                     ),
                 };
                 resolved_args.insert(a.name, v);
             }
             let result = cb.run(name.as_str(), resolved_args.clone()).await?;
-            Box::pin(parse_and_render_at_depth(&result, vars, cb, depth)).await?
+            Box::pin(parse_and_render_at_depth(&result, vars, cb, opt, depth)).await?
         }
         Val::Bool { value } => value.to_string(),
         Val::Null => "".into(),
@@ -163,7 +194,10 @@ mod parse_and_render_tests {
         let template = "";
         let vars = HashMap::new();
         let result = "";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
+        assert_eq!(parse_and_render(template, &vars, &empty_cb, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -173,7 +207,10 @@ mod parse_and_render_tests {
         let template = "Hello World!";
         let vars = HashMap::new();
         let result = "Hello World!";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
+        assert_eq!(parse_and_render(template, &vars, &empty_cb, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -183,7 +220,10 @@ mod parse_and_render_tests {
         let template = "${[ foo ]}";
         let vars = HashMap::from([("foo".to_string(), "bar".to_string())]);
         let result = "bar";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
+        assert_eq!(parse_and_render(template, &vars, &empty_cb, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -197,7 +237,10 @@ mod parse_and_render_tests {
         vars.insert("baz".to_string(), "baz".to_string());
 
         let result = "foo: bar: baz";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
+        assert_eq!(parse_and_render(template, &vars, &empty_cb, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -206,9 +249,11 @@ mod parse_and_render_tests {
         let empty_cb = EmptyCB {};
         let template = "${[ foo ]}";
         let vars = HashMap::new();
-
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
         assert_eq!(
-            parse_and_render(template, &vars, &empty_cb).await,
+            parse_and_render(template, &vars, &empty_cb, &opt).await,
             Err(VariableNotFound("foo".to_string()))
         );
         Ok(())
@@ -220,9 +265,11 @@ mod parse_and_render_tests {
         let template = "${[ foo ]}";
         let mut vars = HashMap::new();
         vars.insert("foo".to_string(), "${[ foo ]}".to_string());
-
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
         assert_eq!(
-            parse_and_render(template, &vars, &empty_cb).await,
+            parse_and_render(template, &vars, &empty_cb, &opt).await,
             Err(RenderStackExceededError)
         );
         Ok(())
@@ -234,7 +281,10 @@ mod parse_and_render_tests {
         let template = "hello ${[ word ]} world!";
         let vars = HashMap::from([("word".to_string(), "cruel".to_string())]);
         let result = "hello cruel world!";
-        assert_eq!(parse_and_render(template, &vars, &empty_cb).await?, result.to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
+        assert_eq!(parse_and_render(template, &vars, &empty_cb, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -243,6 +293,9 @@ mod parse_and_render_tests {
         let vars = HashMap::new();
         let template = r#"${[ say_hello(a='John', b='Kate') ]}"#;
         let result = r#"say_hello: 2, Some(String("John")) Some(String("Kate"))"#;
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
 
         struct CB {}
         impl TemplateCallback for CB {
@@ -263,7 +316,7 @@ mod parse_and_render_tests {
                 Ok(arg_value.to_string())
             }
         }
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result);
+        assert_eq!(parse_and_render(template, &vars, &CB {}, &opt).await?, result);
         Ok(())
     }
 
@@ -272,6 +325,9 @@ mod parse_and_render_tests {
         let vars = HashMap::new();
         let template = r#"${[ upper(foo='bar') ]}"#;
         let result = r#""BAR""#;
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
         struct CB {}
         impl TemplateCallback for CB {
             async fn run(
@@ -296,7 +352,7 @@ mod parse_and_render_tests {
             }
         }
 
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &CB {}, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -306,9 +362,16 @@ mod parse_and_render_tests {
         vars.insert("foo".to_string(), "bar".to_string());
         let template = r#"${[ upper(foo=b64'Zm9vICdiYXInIGJheg') ]}"#;
         let result = r#""FOO 'BAR' BAZ""#;
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
         struct CB {}
         impl TemplateCallback for CB {
-            async fn run(&self, fn_name: &str, args: HashMap<String, serde_json::Value>) -> Result<String> {
+            async fn run(
+                &self,
+                fn_name: &str,
+                args: HashMap<String, serde_json::Value>,
+            ) -> Result<String> {
                 Ok(match fn_name {
                     "upper" => args["foo"].to_string().to_uppercase(),
                     _ => "".to_string(),
@@ -325,7 +388,7 @@ mod parse_and_render_tests {
             }
         }
 
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &CB {}, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -335,9 +398,17 @@ mod parse_and_render_tests {
         vars.insert("foo".to_string(), "bar".to_string());
         let template = r#"${[ upper(foo='${[ foo ]}') ]}"#;
         let result = r#""BAR""#;
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
+
         struct CB {}
         impl TemplateCallback for CB {
-            async fn run(&self, fn_name: &str, args: HashMap<String, serde_json::Value>) -> Result<String> {
+            async fn run(
+                &self,
+                fn_name: &str,
+                args: HashMap<String, serde_json::Value>,
+            ) -> Result<String> {
                 Ok(match fn_name {
                     "secret" => "abc".to_string(),
                     "upper" => args["foo"].to_string().to_uppercase(),
@@ -355,7 +426,7 @@ mod parse_and_render_tests {
             }
         }
 
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &CB {}, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -365,9 +436,17 @@ mod parse_and_render_tests {
         vars.insert("foo".to_string(), "bar".to_string());
         let template = r#"${[ no_op(inner='${[ foo ]}') ]}"#;
         let result = r#""bar""#;
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
+
         struct CB {}
         impl TemplateCallback for CB {
-            async fn run(&self, fn_name: &str, args: HashMap<String, serde_json::Value>) -> Result<String> {
+            async fn run(
+                &self,
+                fn_name: &str,
+                args: HashMap<String, serde_json::Value>,
+            ) -> Result<String> {
                 Ok(match fn_name {
                     "no_op" => args["inner"].to_string(),
                     _ => "".to_string(),
@@ -384,7 +463,7 @@ mod parse_and_render_tests {
             }
         }
 
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &CB {}, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -393,9 +472,17 @@ mod parse_and_render_tests {
         let vars = HashMap::new();
         let template = r#"${[ upper(foo=secret()) ]}"#;
         let result = r#""ABC""#;
+
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
         struct CB {}
         impl TemplateCallback for CB {
-            async fn run(&self, fn_name: &str, args: HashMap<String, serde_json::Value>) -> Result<String> {
+            async fn run(
+                &self,
+                fn_name: &str,
+                args: HashMap<String, serde_json::Value>,
+            ) -> Result<String> {
                 Ok(match fn_name {
                     "secret" => "abc".to_string(),
                     "upper" => args["foo"].to_string().to_uppercase(),
@@ -412,8 +499,7 @@ mod parse_and_render_tests {
                 Ok(arg_value.to_string())
             }
         }
-
-        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
+        assert_eq!(parse_and_render(template, &vars, &CB {}, &opt).await?, result.to_string());
         Ok(())
     }
 
@@ -421,10 +507,17 @@ mod parse_and_render_tests {
     async fn render_fn_err() -> Result<()> {
         let vars = HashMap::new();
         let template = r#"hello ${[ error() ]}"#;
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
 
         struct CB {}
         impl TemplateCallback for CB {
-            async fn run(&self, _fn_name: &str, _args: HashMap<String, serde_json::Value>) -> Result<String> {
+            async fn run(
+                &self,
+                _fn_name: &str,
+                _args: HashMap<String, serde_json::Value>,
+            ) -> Result<String> {
                 Err(RenderError("Failed to do it!".to_string()))
             }
 
@@ -439,7 +532,7 @@ mod parse_and_render_tests {
         }
 
         assert_eq!(
-            parse_and_render(template, &vars, &CB {}).await,
+            parse_and_render(template, &vars, &CB {}, &opt).await,
             Err(RenderError("Failed to do it!".to_string()))
         );
         Ok(())
@@ -449,14 +542,21 @@ mod parse_and_render_tests {
 #[cfg(test)]
 mod render_json_value_raw_tests {
     use crate::error::Result;
-    use crate::{TemplateCallback, render_json_value_raw};
+    use crate::{
+        RenderErrorBehavior, RenderOptions, TemplateCallback, parse_and_render,
+        render_json_value_raw,
+    };
     use serde_json::json;
     use std::collections::HashMap;
 
     struct EmptyCB {}
 
     impl TemplateCallback for EmptyCB {
-        async fn run(&self, _fn_name: &str, _args: HashMap<String, serde_json::Value>) -> Result<String> {
+        async fn run(
+            &self,
+            _fn_name: &str,
+            _args: HashMap<String, serde_json::Value>,
+        ) -> Result<String> {
             todo!()
         }
 
@@ -475,8 +575,11 @@ mod render_json_value_raw_tests {
         let v = json!("${[a]}");
         let mut vars = HashMap::new();
         vars.insert("a".to_string(), "aaa".to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
 
-        assert_eq!(render_json_value_raw(v, &vars, &EmptyCB {}).await?, json!("aaa"));
+        assert_eq!(render_json_value_raw(v, &vars, &EmptyCB {}, &opt).await?, json!("aaa"));
         Ok(())
     }
 
@@ -485,8 +588,11 @@ mod render_json_value_raw_tests {
         let v = json!(["${[a]}", "${[a]}"]);
         let mut vars = HashMap::new();
         vars.insert("a".to_string(), "aaa".to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
 
-        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await?;
+        let result = render_json_value_raw(v, &vars, &EmptyCB {}, &opt).await?;
         assert_eq!(result, json!(["aaa", "aaa"]));
 
         Ok(())
@@ -497,8 +603,11 @@ mod render_json_value_raw_tests {
         let v = json!({"${[a]}": "${[a]}"});
         let mut vars = HashMap::new();
         vars.insert("a".to_string(), "aaa".to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
 
-        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await?;
+        let result = render_json_value_raw(v, &vars, &EmptyCB {}, &opt).await?;
         assert_eq!(result, json!({"aaa": "aaa"}));
 
         Ok(())
@@ -516,8 +625,11 @@ mod render_json_value_raw_tests {
         ]);
         let mut vars = HashMap::new();
         vars.insert("a".to_string(), "aaa".to_string());
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        };
 
-        let result = render_json_value_raw(v, &vars, &EmptyCB {}).await?;
+        let result = render_json_value_raw(v, &vars, &EmptyCB {}, &opt).await?;
         assert_eq!(
             result,
             json!([
@@ -532,4 +644,17 @@ mod render_json_value_raw_tests {
 
         Ok(())
     }
+
+    #[tokio::test]
+    async fn render_opt_return_empty() -> Result<()> {
+        let vars = HashMap::new();
+        let opt = RenderOptions {
+            error_behavior: RenderErrorBehavior::ReturnEmpty,
+        };
+
+        let result = parse_and_render("DNE: ${[hello]}", &vars, &EmptyCB {}, &opt).await?;
+        assert_eq!(result, "DNE: ".to_string());
+
+        Ok(())
+    }
 }

src-tauri/yaak-ws/src/commands.rs

@@ -22,6 +22,7 @@ use yaak_plugins::events::{
 };
 use yaak_plugins::manager::PluginManager;
 use yaak_plugins::template_callback::PluginTemplateCallback;
+use yaak_templates::{RenderErrorBehavior, RenderOptions};
 
 #[tauri::command]
 pub(crate) async fn upsert_request<R: Runtime>(
@@ -126,6 +127,9 @@ pub(crate) async fn send<R: Runtime>(
             &PluginWindowContext::new(&window),
             RenderPurpose::Send,
         ),
+        &RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        },
     )
     .await?;
 
@@ -202,6 +206,9 @@ pub(crate) async fn connect<R: Runtime>(
             &PluginWindowContext::new(&window),
             RenderPurpose::Send,
         ),
+        &RenderOptions {
+            error_behavior: RenderErrorBehavior::Throw,
+        },
     )
     .await?;
 

src-tauri/yaak-ws/src/render.rs

@@ -2,12 +2,13 @@ use crate::error::Result;
 use std::collections::BTreeMap;
 use yaak_models::models::{Environment, HttpRequestHeader, WebsocketRequest};
 use yaak_models::render::make_vars_hashmap;
-use yaak_templates::{parse_and_render, render_json_value_raw, TemplateCallback};
+use yaak_templates::{parse_and_render, render_json_value_raw, RenderOptions, TemplateCallback};
 
 pub async fn render_websocket_request<T: TemplateCallback>(
     r: &WebsocketRequest,
     environment_chain: Vec<Environment>,
     cb: &T,
+    opt: &RenderOptions,
 ) -> Result<WebsocketRequest> {
     let vars = &make_vars_hashmap(environment_chain);
 
@@ -15,20 +16,20 @@ pub async fn render_websocket_request<T: TemplateCallback>(
     for p in r.headers.clone() {
         headers.push(HttpRequestHeader {
             enabled: p.enabled,
-            name: parse_and_render(&p.name, vars, cb).await?,
-            value: parse_and_render(&p.value, vars, cb).await?,
+            name: parse_and_render(&p.name, vars, cb, opt).await?,
+            value: parse_and_render(&p.value, vars, cb, opt).await?,
             id: p.id,
         })
     }
 
     let mut authentication = BTreeMap::new();
     for (k, v) in r.authentication.clone() {
-        authentication.insert(k, render_json_value_raw(v, vars, cb).await?);
+        authentication.insert(k, render_json_value_raw(v, vars, cb, opt).await?);
     }
 
-    let url = parse_and_render(r.url.as_str(), vars, cb).await?;
+    let url = parse_and_render(r.url.as_str(), vars, cb, opt).await?;
 
-    let message = parse_and_render(&r.message.clone(), vars, cb).await?;
+    let message = parse_and_render(&r.message.clone(), vars, cb, opt).await?;
 
     Ok(WebsocketRequest {
         url,

src-web/commands/createEnvironment.ts

@@ -5,7 +5,7 @@ import { jotaiStore } from '../lib/jotai';
 import { showPrompt } from '../lib/prompt';
 import { setWorkspaceSearchParams } from '../lib/setWorkspaceSearchParams';
 
-export const createEnvironmentAndActivate = createFastMutation<
+export const createSubEnvironmentAndActivate = createFastMutation<
   string | null,
   unknown,
   Environment | null
@@ -46,7 +46,6 @@ export const createEnvironmentAndActivate = createFastMutation<
       return; // Was not created
     }
 
-    console.log('NAVIGATING', jotaiStore.get(activeWorkspaceIdAtom), environmentId);
     setWorkspaceSearchParams({ environment_id: environmentId });
   },
 });

src-web/components/CommandPaletteDialog.tsx

@@ -5,7 +5,7 @@ import { useAtomValue } from 'jotai';
 import type { KeyboardEvent, ReactNode } from 'react';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { createFolder } from '../commands/commands';
-import { createEnvironmentAndActivate } from '../commands/createEnvironment';
+import { createSubEnvironmentAndActivate } from '../commands/createEnvironment';
 import { openSettings } from '../commands/openSettings';
 import { switchWorkspace } from '../commands/switchWorkspace';
 import { useActiveCookieJar } from '../hooks/useActiveCookieJar';
@@ -130,7 +130,7 @@ export function CommandPaletteDialog({ onClose }: { onClose: () => void }) {
       {
         key: 'environment.create',
         label: 'Create Environment',
-        onSelect: () => createEnvironmentAndActivate.mutate(baseEnvironment),
+        onSelect: () => createSubEnvironmentAndActivate.mutate(baseEnvironment),
       },
       {
         key: 'sidebar.toggle',

src-web/components/EnvironmentEditDialog.tsx

@@ -3,7 +3,7 @@ import { duplicateModel, patchModel } from '@yaakapp-internal/models';
 import classNames from 'classnames';
 import type { ReactNode } from 'react';
 import React, { useCallback, useState } from 'react';
-import { createEnvironmentAndActivate } from '../commands/createEnvironment';
+import { createSubEnvironmentAndActivate } from '../commands/createEnvironment';
 import { useEnvironmentsBreakdown } from '../hooks/useEnvironmentsBreakdown';
 import { deleteModelWithConfirm } from '../lib/deleteModelWithConfirm';
 import { isBaseEnvironment } from '../lib/model_util';
@@ -42,7 +42,7 @@ export const EnvironmentEditDialog = function ({ initialEnvironment }: Props) {
 
   const handleCreateEnvironment = async () => {
     if (baseEnvironment == null) return;
-    const id = await createEnvironmentAndActivate.mutateAsync(baseEnvironment);
+    const id = await createSubEnvironmentAndActivate.mutateAsync(baseEnvironment);
     if (id != null) setSelectedEnvironmentId(id);
   };
 

src-web/components/Overlay.tsx

@@ -1,5 +1,5 @@
 import classNames from 'classnames';
-import FocusTrap from 'focus-trap-react';
+import { FocusTrap } from 'focus-trap-react';
 import * as m from 'motion/react-m';
 import type { ReactNode } from 'react';
 import React from 'react';
@@ -47,7 +47,11 @@ export function Overlay({
   return (
     <Portal name={portalName}>
       {open && (
-        <FocusTrap>
+        <FocusTrap
+          focusTrapOptions={{
+            allowOutsideClick: true, // So we can still click toasts and things
+          }}
+        >
           <m.div
             className={classNames('fixed inset-0', zIndexes[zIndex])}
             initial={{ opacity: 0 }}

src-web/components/WorkspaceActionsDropdown.tsx

@@ -7,7 +7,11 @@ import { memo, useCallback, useMemo } from 'react';
 import { openWorkspaceFromSyncDir } from '../commands/openWorkspaceFromSyncDir';
 import { openWorkspaceSettings } from '../commands/openWorkspaceSettings';
 import { switchWorkspace } from '../commands/switchWorkspace';
-import { activeWorkspaceAtom, activeWorkspaceMetaAtom } from '../hooks/useActiveWorkspace';
+import {
+  activeWorkspaceAtom,
+  activeWorkspaceIdAtom,
+  activeWorkspaceMetaAtom,
+} from '../hooks/useActiveWorkspace';
 import { useCreateWorkspace } from '../hooks/useCreateWorkspace';
 import { useDeleteSendHistory } from '../hooks/useDeleteSendHistory';
 import { showDialog } from '../lib/dialog';
@@ -95,7 +99,12 @@ export const WorkspaceActionsDropdown = memo(function WorkspaceActionsDropdown({
     if (workspaceId == null) return;
 
     const settings = jotaiStore.get(settingsAtom);
-    if (typeof settings.openWorkspaceNewWindow === 'boolean') {
+    const activeWorkspaceId = jotaiStore.get(activeWorkspaceIdAtom);
+    if (workspaceId === activeWorkspaceId) {
+      // Always open a new window if the selected one is already active
+      switchWorkspace.mutate({ workspaceId, inNewWindow: true });
+      return;
+    } else if (typeof settings.openWorkspaceNewWindow === 'boolean') {
       switchWorkspace.mutate({ workspaceId, inNewWindow: settings.openWorkspaceNewWindow });
       return;
     }

src-web/components/core/Confirm.tsx

@@ -44,7 +44,7 @@ export function Confirm({
           onChange={setConfirm}
           label={
             <>
-              Type <strong>{requireTyping}</strong> to confirm
+              Type <strong className="select-auto cursor-text">{requireTyping}</strong> to confirm
             </>
           }
         />

src-web/main.css

@@ -48,10 +48,6 @@
     }
   }
 
-  .select-all * {
-    /*@apply select-all;*/
-  }
-
   a,
   a[href] * {
     @apply cursor-pointer !important;