Filesystem Sync (#142)

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

@@ -0,0 +1,45 @@
+use thiserror::Error;
+use tokio::io;
+use tokio::sync::mpsc::error::SendError;
+use crate::server::plugin_runtime::EventStreamEvent;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("IO error: {0}")]
+    IoErr(#[from] io::Error),
+    
+    #[error("Tauri error: {0}")]
+    TauriErr(#[from] tauri::Error),
+    
+    #[error("Tauri shell error: {0}")]
+    TauriShellErr(#[from] tauri_plugin_shell::Error),
+    
+    #[error("Grpc transport error: {0}")]
+    GrpcTransportErr(#[from] tonic::transport::Error),
+    
+    #[error("Grpc send error: {0}")]
+    GrpcSendErr(#[from] SendError<tonic::Result<EventStreamEvent>>),
+    
+    #[error("JSON error: {0}")]
+    JsonErr(#[from] serde_json::Error),
+    
+    #[error("Plugin not found: {0}")]
+    PluginNotFoundErr(String),
+    
+    #[error("Plugin error: {0}")]
+    PluginErr(String),
+    
+    #[error("Client not initialized error")]
+    ClientNotInitializedErr,
+    
+    #[error("Unknown event received")]
+    UnknownEventErr,
+}
+
+impl Into<String> for Error {
+    fn into(self) -> String {
+        todo!()
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

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

@@ -0,0 +1,536 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use tauri::{Runtime, WebviewWindow};
+use ts_rs::TS;
+
+use yaak_models::models::{Environment, Folder, GrpcRequest, HttpRequest, HttpResponse, Workspace};
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct InternalEvent {
+    pub id: String,
+    pub plugin_ref_id: String,
+    pub reply_id: Option<String>,
+    pub payload: InternalEventPayload,
+    pub window_context: WindowContext,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export, export_to = "events.ts")]
+pub enum WindowContext {
+    None,
+    Label { label: String },
+}
+
+impl WindowContext {
+    pub fn from_window<R: Runtime>(window: &WebviewWindow<R>) -> Self {
+        Self::Label {
+            label: window.label().to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export, export_to = "events.ts")]
+pub enum InternalEventPayload {
+    BootRequest(BootRequest),
+    BootResponse(BootResponse),
+
+    ReloadRequest,
+    ReloadResponse,
+
+    TerminateRequest,
+    TerminateResponse,
+
+    ImportRequest(ImportRequest),
+    ImportResponse(ImportResponse),
+
+    FilterRequest(FilterRequest),
+    FilterResponse(FilterResponse),
+
+    ExportHttpRequestRequest(ExportHttpRequestRequest),
+    ExportHttpRequestResponse(ExportHttpRequestResponse),
+
+    SendHttpRequestRequest(SendHttpRequestRequest),
+    SendHttpRequestResponse(SendHttpRequestResponse),
+
+    GetHttpRequestActionsRequest(GetHttpRequestActionsRequest),
+    GetHttpRequestActionsResponse(GetHttpRequestActionsResponse),
+    CallHttpRequestActionRequest(CallHttpRequestActionRequest),
+
+    GetTemplateFunctionsRequest,
+    GetTemplateFunctionsResponse(GetTemplateFunctionsResponse),
+    CallTemplateFunctionRequest(CallTemplateFunctionRequest),
+    CallTemplateFunctionResponse(CallTemplateFunctionResponse),
+
+    CopyTextRequest(CopyTextRequest),
+
+    RenderHttpRequestRequest(RenderHttpRequestRequest),
+    RenderHttpRequestResponse(RenderHttpRequestResponse),
+
+    TemplateRenderRequest(TemplateRenderRequest),
+    TemplateRenderResponse(TemplateRenderResponse),
+
+    ShowToastRequest(ShowToastRequest),
+
+    PromptTextRequest(PromptTextRequest),
+    PromptTextResponse(PromptTextResponse),
+
+    GetHttpRequestByIdRequest(GetHttpRequestByIdRequest),
+    GetHttpRequestByIdResponse(GetHttpRequestByIdResponse),
+
+    FindHttpResponsesRequest(FindHttpResponsesRequest),
+    FindHttpResponsesResponse(FindHttpResponsesResponse),
+
+    /// Returned when a plugin doesn't get run, just so the server
+    /// has something to listen for
+    EmptyResponse,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct BootRequest {
+    pub dir: String,
+    pub watch: bool,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct BootResponse {
+    pub name: String,
+    pub version: String,
+    pub capabilities: Vec<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct ImportRequest {
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct ImportResponse {
+    pub resources: ImportResources,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct FilterRequest {
+    pub content: String,
+    pub filter: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct FilterResponse {
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct ExportHttpRequestRequest {
+    pub http_request: HttpRequest,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct ExportHttpRequestResponse {
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct SendHttpRequestRequest {
+    pub http_request: HttpRequest,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct SendHttpRequestResponse {
+    pub http_response: HttpResponse,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct CopyTextRequest {
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct RenderHttpRequestRequest {
+    pub http_request: HttpRequest,
+    pub purpose: RenderPurpose,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct RenderHttpRequestResponse {
+    pub http_request: HttpRequest,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateRenderRequest {
+    pub data: serde_json::Value,
+    pub purpose: RenderPurpose,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateRenderResponse {
+    pub data: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct ShowToastRequest {
+    pub message: String,
+    #[ts(optional)]
+    pub color: Option<Color>,
+    #[ts(optional)]
+    pub icon: Option<Icon>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct PromptTextRequest {
+    // A unique ID to identify the prompt (eg. "enter-password")
+    pub id: String,
+    // Title to show on the prompt dialog
+    pub title: String,
+    // Text to show on the label above the input
+    pub label: String,
+    #[ts(optional)]
+    pub description: Option<String>,
+    #[ts(optional)]
+    pub default_value: Option<String>,
+    #[ts(optional)]
+    pub placeholder: Option<String>,
+    /// Text to add to the confirmation button
+    #[ts(optional)]
+    pub confirm_text: Option<String>,
+    /// Text to add to the cancel button
+    #[ts(optional)]
+    pub cancel_text: Option<String>,
+    /// Require the user to enter a non-empty value
+    #[ts(optional)]
+    pub require: Option<bool>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct PromptTextResponse {
+    pub value: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case")]
+#[ts(export, export_to = "events.ts")]
+pub enum Color {
+    Custom,
+    Default,
+    Primary,
+    Secondary,
+    Info,
+    Success,
+    Notice,
+    Warning,
+    Danger,
+}
+
+impl Default for Color {
+    fn default() -> Self {
+        Color::Default
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case")]
+#[ts(export, export_to = "events.ts")]
+pub enum Icon {
+    Copy,
+    Info,
+    CheckCircle,
+    AlertTriangle,
+
+    #[serde(untagged)]
+    #[ts(type = "\"_unknown\"")]
+    _Unknown(String),
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct GetTemplateFunctionsResponse {
+    pub functions: Vec<TemplateFunction>,
+    pub plugin_ref_id: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateFunction {
+    pub name: String,
+    #[ts(optional)]
+    pub description: Option<String>,
+
+    /// Also support alternative names. This is useful for not breaking existing
+    /// tags when changing the `name` property
+    #[ts(optional)]
+    pub aliases: Option<Vec<String>>,
+    pub args: Vec<TemplateFunctionArg>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export, export_to = "events.ts")]
+pub enum TemplateFunctionArg {
+    Text(TemplateFunctionTextArg),
+    Select(TemplateFunctionSelectArg),
+    Checkbox(TemplateFunctionCheckboxArg),
+    HttpRequest(TemplateFunctionHttpRequestArg),
+    File(TemplateFunctionFileArg),
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateFunctionBaseArg {
+    /// The name of the argument. Should be `camelCase` format
+    pub name: String,
+
+    /// Whether the user must fill in the argument
+    #[ts(optional)]
+    pub optional: Option<bool>,
+
+    /// The label of the input
+    #[ts(optional)]
+    pub label: Option<String>,
+
+    /// The default value
+    #[ts(optional)]
+    pub default_value: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateFunctionTextArg {
+    #[serde(flatten)]
+    pub base: TemplateFunctionBaseArg,
+
+    /// Placeholder for the text input
+    #[ts(optional)]
+    pub placeholder: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateFunctionHttpRequestArg {
+    #[serde(flatten)]
+    pub base: TemplateFunctionBaseArg,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateFunctionFileArg {
+    #[serde(flatten)]
+    pub base: TemplateFunctionBaseArg,
+
+    /// The title of the file selection window
+    pub title: String,
+
+    /// Allow selecting multiple files
+    #[ts(optional)]
+    pub multiple: Option<bool>,
+
+    // Select a directory, not a file
+    #[ts(optional)]
+    pub directory: Option<bool>,
+
+    // Default file path for selection dialog
+    #[ts(optional)]
+    pub default_path: Option<String>,
+
+    // Specify to only allow selection of certain file extensions
+    #[ts(optional)]
+    pub filters: Option<Vec<OpenFileFilter>>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct OpenFileFilter {
+    pub name: String,
+    /// File extensions to require
+    pub extensions: Vec<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateFunctionSelectArg {
+    #[serde(flatten)]
+    pub base: TemplateFunctionBaseArg,
+
+    /// The options that will be available in the select input
+    pub options: Vec<TemplateFunctionSelectOption>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateFunctionCheckboxArg {
+    #[serde(flatten)]
+    pub base: TemplateFunctionBaseArg,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct TemplateFunctionSelectOption {
+    pub label: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct CallTemplateFunctionRequest {
+    pub name: String,
+    pub args: CallTemplateFunctionArgs,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct CallTemplateFunctionResponse {
+    pub value: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct CallTemplateFunctionArgs {
+    pub purpose: RenderPurpose,
+    pub values: HashMap<String, String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case")]
+#[ts(export, export_to = "events.ts")]
+pub enum RenderPurpose {
+    Send,
+    Preview,
+}
+
+impl Default for RenderPurpose {
+    fn default() -> Self {
+        RenderPurpose::Preview
+    }
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default)]
+#[ts(export, export_to = "events.ts")]
+pub struct GetHttpRequestActionsRequest {}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct GetHttpRequestActionsResponse {
+    pub actions: Vec<HttpRequestAction>,
+    pub plugin_ref_id: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct HttpRequestAction {
+    pub key: String,
+    pub label: String,
+    #[ts(optional)]
+    pub icon: Option<Icon>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct CallHttpRequestActionRequest {
+    pub key: String,
+    pub plugin_ref_id: String,
+    pub args: CallHttpRequestActionArgs,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct CallHttpRequestActionArgs {
+    pub http_request: HttpRequest,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct GetHttpRequestByIdRequest {
+    pub id: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct GetHttpRequestByIdResponse {
+    pub http_request: Option<HttpRequest>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct FindHttpResponsesRequest {
+    pub request_id: String,
+    #[ts(optional)]
+    pub limit: Option<i32>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct FindHttpResponsesResponse {
+    pub http_responses: Vec<HttpResponse>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "events.ts")]
+pub struct ImportResources {
+    pub workspaces: Vec<Workspace>,
+    pub environments: Vec<Environment>,
+    pub folders: Vec<Folder>,
+    pub http_requests: Vec<HttpRequest>,
+    pub grpc_requests: Vec<GrpcRequest>,
+}

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

@@ -0,0 +1,37 @@
+use std::process::exit;
+use log::info;
+use tauri::plugin::{Builder, TauriPlugin};
+use tauri::{Manager, RunEvent, Runtime, State};
+use crate::manager::PluginManager;
+
+pub mod error;
+pub mod events;
+pub mod manager;
+mod nodejs;
+mod server;
+pub mod plugin_handle;
+mod util;
+
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    Builder::new("yaak-plugins")
+        .setup(|app_handle, _| {
+            let manager = PluginManager::new(app_handle.clone());
+            app_handle.manage(manager.clone());
+
+            Ok(())
+        })
+        .on_event(|app, e| match e {
+            // TODO: Also exit when app is force-quit (eg. cmd+r in IntelliJ runner)
+            RunEvent::ExitRequested { api, .. } => {
+                api.prevent_exit();
+                tauri::async_runtime::block_on(async move {
+                    info!("Exiting plugin runtime due to app exit");
+                    let manager: State<PluginManager> = app.state();
+                    manager.terminate().await;
+                    exit(0);
+                });
+            }
+            _ => {}
+        })
+        .build()
+}

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

@@ -0,0 +1,593 @@
+use crate::error::Error::{ClientNotInitializedErr, PluginErr, PluginNotFoundErr, UnknownEventErr};
+use crate::error::Result;
+use crate::events::{
+    BootRequest, CallHttpRequestActionRequest, CallTemplateFunctionArgs,
+    CallTemplateFunctionRequest, CallTemplateFunctionResponse, FilterRequest, FilterResponse,
+    GetHttpRequestActionsRequest, GetHttpRequestActionsResponse, GetTemplateFunctionsResponse,
+    ImportRequest, ImportResponse, InternalEvent, InternalEventPayload, RenderPurpose,
+    WindowContext,
+};
+use crate::nodejs::start_nodejs_plugin_runtime;
+use crate::plugin_handle::PluginHandle;
+use crate::server::plugin_runtime::plugin_runtime_server::PluginRuntimeServer;
+use crate::server::PluginRuntimeServerImpl;
+use log::{info, warn};
+use std::collections::HashMap;
+use std::env;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+use tauri::path::BaseDirectory;
+use tauri::{AppHandle, Manager, Runtime, WebviewWindow};
+use tokio::fs::read_dir;
+use tokio::net::TcpListener;
+use tokio::sync::{mpsc, Mutex};
+use tonic::codegen::tokio_stream;
+use tonic::transport::Server;
+use yaak_models::queries::{generate_id, list_plugins};
+
+#[derive(Clone)]
+pub struct PluginManager {
+    subscribers: Arc<Mutex<HashMap<String, mpsc::Sender<InternalEvent>>>>,
+    plugins: Arc<Mutex<Vec<PluginHandle>>>,
+    kill_tx: tokio::sync::watch::Sender<bool>,
+    grpc_service: Arc<PluginRuntimeServerImpl>,
+}
+
+#[derive(Clone)]
+struct PluginCandidate {
+    dir: String,
+    watch: bool,
+}
+
+impl PluginManager {
+    pub fn new<R: Runtime>(app_handle: AppHandle<R>) -> PluginManager {
+        let (events_tx, mut events_rx) = mpsc::channel(128);
+        let (kill_server_tx, kill_server_rx) = tokio::sync::watch::channel(false);
+
+        let (client_disconnect_tx, mut client_disconnect_rx) = mpsc::channel(128);
+        let (client_connect_tx, mut client_connect_rx) = tokio::sync::watch::channel(false);
+        let grpc_service =
+            PluginRuntimeServerImpl::new(events_tx, client_disconnect_tx, client_connect_tx);
+
+        let plugin_manager = PluginManager {
+            plugins: Arc::new(Mutex::new(Vec::new())),
+            subscribers: Arc::new(Mutex::new(HashMap::new())),
+            grpc_service: Arc::new(grpc_service.clone()),
+            kill_tx: kill_server_tx,
+        };
+
+        // Forward events to subscribers
+        let subscribers = plugin_manager.subscribers.clone();
+        tauri::async_runtime::spawn(async move {
+            while let Some(event) = events_rx.recv().await {
+                for (tx_id, tx) in subscribers.lock().await.iter_mut() {
+                    if let Err(e) = tx.try_send(event.clone()) {
+                        warn!("Failed to send event to subscriber {tx_id} {e:?}");
+                    }
+                }
+            }
+        });
+
+        // Handle when client plugin runtime disconnects
+        tauri::async_runtime::spawn(async move {
+            while let Some(_) = client_disconnect_rx.recv().await {
+                info!("Plugin runtime client disconnected! TODO: Handle this case");
+            }
+        });
+
+        info!("Starting plugin server");
+
+        let svc = PluginRuntimeServer::new(grpc_service.to_owned())
+            .max_encoding_message_size(usize::MAX)
+            .max_decoding_message_size(usize::MAX);
+        let listen_addr = match option_env!("PORT") {
+            None => "localhost:0".to_string(),
+            Some(port) => format!("localhost:{port}"),
+        };
+        let listener = tauri::async_runtime::block_on(async move {
+            TcpListener::bind(listen_addr).await.expect("Failed to bind TCP listener")
+        });
+        let addr = listener.local_addr().expect("Failed to get local address");
+
+        // 1. Reload all plugins when the Node.js runtime connects
+        {
+            let plugin_manager = plugin_manager.clone();
+            let app_handle = app_handle.clone();
+            tauri::async_runtime::spawn(async move {
+                match client_connect_rx.changed().await {
+                    Ok(_) => {
+                        info!("Plugin runtime client connected!");
+                        plugin_manager
+                            .initialize_all_plugins(&app_handle, WindowContext::None)
+                            .await
+                            .expect("Failed to reload plugins");
+                    }
+                    Err(e) => {
+                        warn!("Failed to receive from client connection rx {e:?}");
+                    }
+                }
+            });
+        };
+
+        // 1. Spawn server in the background
+        info!("Starting gRPC plugin server on {addr}");
+        tauri::async_runtime::spawn(async move {
+            Server::builder()
+                .timeout(Duration::from_secs(10))
+                .add_service(svc)
+                .serve_with_incoming(tokio_stream::wrappers::TcpListenerStream::new(listener))
+                .await
+                .expect("grpc plugin runtime server failed to start");
+        });
+
+        // 2. Start Node.js runtime and initialize plugins
+        tauri::async_runtime::block_on(async move {
+            start_nodejs_plugin_runtime(&app_handle, addr, &kill_server_rx).await.unwrap();
+        });
+
+        plugin_manager
+    }
+
+    async fn list_plugin_dirs<R: Runtime>(
+        &self,
+        app_handle: &AppHandle<R>,
+    ) -> Vec<PluginCandidate> {
+        let bundled_plugins_dir = &app_handle
+            .path()
+            .resolve("vendored/plugins", BaseDirectory::Resource)
+            .expect("failed to resolve plugin directory resource");
+
+        let plugins_dir = match env::var("YAAK_PLUGINS_DIR") {
+            Ok(d) => &PathBuf::from(d),
+            Err(_) => bundled_plugins_dir,
+        };
+
+        info!("Loading bundled plugins from {plugins_dir:?}");
+
+        let bundled_plugin_dirs: Vec<PluginCandidate> = read_plugins_dir(&plugins_dir)
+            .await
+            .expect(format!("Failed to read plugins dir: {:?}", plugins_dir).as_str())
+            .iter()
+            .map(|d| {
+                let is_vendored = plugins_dir.starts_with(bundled_plugins_dir);
+                PluginCandidate {
+                    dir: d.into(),
+                    watch: !is_vendored,
+                }
+            })
+            .collect();
+
+        let plugins = list_plugins(app_handle).await.unwrap_or_default();
+        let installed_plugin_dirs: Vec<PluginCandidate> = plugins
+            .iter()
+            .map(|p| PluginCandidate {
+                dir: p.directory.to_owned(),
+                watch: true,
+            })
+            .collect();
+
+        [bundled_plugin_dirs, installed_plugin_dirs].concat()
+    }
+
+    pub async fn uninstall(&self, window_context: WindowContext, dir: &str) -> Result<()> {
+        let plugin = self.get_plugin_by_dir(dir).await.ok_or(PluginNotFoundErr(dir.to_string()))?;
+        self.remove_plugin(window_context, &plugin).await
+    }
+
+    async fn remove_plugin(
+        &self,
+        window_context: WindowContext,
+        plugin: &PluginHandle,
+    ) -> Result<()> {
+        // Terminate the plugin
+        plugin.terminate(window_context).await?;
+
+        // Remove the plugin from the list
+        let mut plugins = self.plugins.lock().await;
+        let pos = plugins.iter().position(|p| p.ref_id == plugin.ref_id);
+        if let Some(pos) = pos {
+            plugins.remove(pos);
+        }
+
+        Ok(())
+    }
+
+    pub async fn add_plugin_by_dir(
+        &self,
+        window_context: WindowContext,
+        dir: &str,
+        watch: bool,
+    ) -> Result<()> {
+        info!("Adding plugin by dir {dir}");
+        let maybe_tx = self.grpc_service.app_to_plugin_events_tx.lock().await;
+        let tx = match &*maybe_tx {
+            None => return Err(ClientNotInitializedErr),
+            Some(tx) => tx,
+        };
+        let plugin_handle = PluginHandle::new(dir, tx.clone());
+
+        // Add the new plugin
+        self.plugins.lock().await.push(plugin_handle.clone());
+
+        // Boot the plugin
+        let event = self
+            .send_to_plugin_and_wait(
+                window_context,
+                &plugin_handle,
+                &InternalEventPayload::BootRequest(BootRequest {
+                    dir: dir.to_string(),
+                    watch,
+                }),
+            )
+            .await?;
+
+        let resp = match event.payload {
+            InternalEventPayload::BootResponse(resp) => resp,
+            _ => return Err(UnknownEventErr),
+        };
+
+        // Set the boot response
+        plugin_handle.set_boot_response(&resp).await;
+
+        Ok(())
+    }
+
+    pub async fn initialize_all_plugins<R: Runtime>(
+        &self,
+        app_handle: &AppHandle<R>,
+        window_context: WindowContext,
+    ) -> Result<()> {
+        let dirs = self.list_plugin_dirs(app_handle).await;
+        for d in dirs.clone() {
+            // First remove the plugin if it exists
+            if let Some(plugin) = self.get_plugin_by_dir(d.dir.as_str()).await {
+                if let Err(e) = self.remove_plugin(window_context.to_owned(), &plugin).await {
+                    warn!("Failed to remove plugin {} {e:?}", d.dir);
+                }
+            }
+            if let Err(e) =
+                self.add_plugin_by_dir(window_context.to_owned(), d.dir.as_str(), d.watch).await
+            {
+                warn!("Failed to add plugin {} {e:?}", d.dir);
+            }
+        }
+
+        info!(
+            "Initialized all plugins:\n  - {}",
+            self.plugins
+                .lock()
+                .await
+                .iter()
+                .map(|p| p.dir.to_string())
+                .collect::<Vec<String>>()
+                .join("\n  - "),
+        );
+
+        Ok(())
+    }
+
+    pub async fn subscribe(&self, label: &str) -> (String, mpsc::Receiver<InternalEvent>) {
+        let (tx, rx) = mpsc::channel(128);
+        let rx_id = format!("{label}_{}", generate_id());
+        self.subscribers.lock().await.insert(rx_id.clone(), tx);
+        (rx_id, rx)
+    }
+
+    pub async fn unsubscribe(&self, rx_id: &str) {
+        self.subscribers.lock().await.remove(rx_id);
+    }
+
+    pub async fn terminate(&self) {
+        self.kill_tx.send_replace(true);
+
+        // Give it a bit of time to kill
+        tokio::time::sleep(Duration::from_millis(500)).await;
+    }
+
+    pub async fn reply(
+        &self,
+        source_event: &InternalEvent,
+        payload: &InternalEventPayload,
+    ) -> Result<()> {
+        let window_label = source_event.to_owned().window_context;
+        let reply_id = Some(source_event.to_owned().id);
+        let plugin = self
+            .get_plugin_by_ref_id(source_event.plugin_ref_id.as_str())
+            .await
+            .ok_or(PluginNotFoundErr(source_event.plugin_ref_id.to_string()))?;
+        let event = plugin.build_event_to_send_raw(window_label, &payload, reply_id);
+        plugin.send(&event).await
+    }
+
+    pub async fn get_plugin_by_ref_id(&self, ref_id: &str) -> Option<PluginHandle> {
+        self.plugins.lock().await.iter().find(|p| p.ref_id == ref_id).cloned()
+    }
+
+    pub async fn get_plugin_by_dir(&self, dir: &str) -> Option<PluginHandle> {
+        self.plugins.lock().await.iter().find(|p| p.dir == dir).cloned()
+    }
+
+    pub async fn get_plugin_by_name(&self, name: &str) -> Option<PluginHandle> {
+        for plugin in self.plugins.lock().await.iter().cloned() {
+            let info = plugin.info().await;
+            if info.name == name {
+                return Some(plugin);
+            }
+        }
+        None
+    }
+
+    async fn send_to_plugin_and_wait(
+        &self,
+        window_context: WindowContext,
+        plugin: &PluginHandle,
+        payload: &InternalEventPayload,
+    ) -> Result<InternalEvent> {
+        let events =
+            self.send_to_plugins_and_wait(window_context, payload, vec![plugin.to_owned()]).await?;
+        Ok(events.first().unwrap().to_owned())
+    }
+
+    async fn send_and_wait(
+        &self,
+        window_context: WindowContext,
+        payload: &InternalEventPayload,
+    ) -> Result<Vec<InternalEvent>> {
+        let plugins = { self.plugins.lock().await.clone() };
+        self.send_to_plugins_and_wait(window_context, payload, plugins).await
+    }
+
+    async fn send_to_plugins_and_wait(
+        &self,
+        window_context: WindowContext,
+        payload: &InternalEventPayload,
+        plugins: Vec<PluginHandle>,
+    ) -> Result<Vec<InternalEvent>> {
+        let label = format!("wait[{}]", plugins.len());
+        let (rx_id, mut rx) = self.subscribe(label.as_str()).await;
+
+        // 1. Build the events with IDs and everything
+        let events_to_send = plugins
+            .iter()
+            .map(|p| p.build_event_to_send(window_context.to_owned(), payload, None))
+            .collect::<Vec<InternalEvent>>();
+
+        // 2. Spawn thread to subscribe to incoming events and check reply ids
+        let send_events_fut = {
+            let events_to_send = events_to_send.clone();
+
+            tokio::spawn(async move {
+                let mut found_events = Vec::new();
+
+                while let Some(event) = rx.recv().await {
+                    if events_to_send
+                        .iter()
+                        .find(|e| Some(e.id.to_owned()) == event.reply_id)
+                        .is_some()
+                    {
+                        found_events.push(event.clone());
+                    };
+                    if found_events.len() == events_to_send.len() {
+                        break;
+                    }
+                }
+
+                found_events
+            })
+        };
+
+        // 3. Send the events
+        for event in events_to_send {
+            let plugin = plugins
+                .iter()
+                .find(|p| p.ref_id == event.plugin_ref_id)
+                .expect("Didn't find plugin in list");
+            plugin.send(&event).await?
+        }
+
+        // 4. Join on the spawned thread
+        let events = send_events_fut.await.expect("Thread didn't succeed");
+
+        // 5. Unsubscribe
+        self.unsubscribe(rx_id.as_str()).await;
+
+        Ok(events)
+    }
+
+    pub async fn get_http_request_actions<R: Runtime>(
+        &self,
+        window: &WebviewWindow<R>,
+    ) -> Result<Vec<GetHttpRequestActionsResponse>> {
+        let reply_events = self
+            .send_and_wait(
+                WindowContext::from_window(window),
+                &InternalEventPayload::GetHttpRequestActionsRequest(
+                    GetHttpRequestActionsRequest {},
+                ),
+            )
+            .await?;
+
+        let mut all_actions = Vec::new();
+        for event in reply_events {
+            if let InternalEventPayload::GetHttpRequestActionsResponse(resp) = event.payload {
+                all_actions.push(resp.clone());
+            }
+        }
+
+        Ok(all_actions)
+    }
+
+    pub async fn get_template_functions<R: Runtime>(
+        &self,
+        window: &WebviewWindow<R>,
+    ) -> Result<Vec<GetTemplateFunctionsResponse>> {
+        self.get_template_functions_with_context(WindowContext::from_window(window)).await
+    }
+
+    pub async fn get_template_functions_with_context(
+        &self,
+        window_context: WindowContext,
+    ) -> Result<Vec<GetTemplateFunctionsResponse>> {
+        let reply_events = self
+            .send_and_wait(window_context, &InternalEventPayload::GetTemplateFunctionsRequest)
+            .await?;
+
+        let mut all_actions = Vec::new();
+        for event in reply_events {
+            if let InternalEventPayload::GetTemplateFunctionsResponse(resp) = event.payload {
+                all_actions.push(resp.clone());
+            }
+        }
+
+        Ok(all_actions)
+    }
+
+    pub async fn call_http_request_action<R: Runtime>(
+        &self,
+        window: &WebviewWindow<R>,
+        req: CallHttpRequestActionRequest,
+    ) -> Result<()> {
+        let ref_id = req.plugin_ref_id.clone();
+        let plugin =
+            self.get_plugin_by_ref_id(ref_id.as_str()).await.ok_or(PluginNotFoundErr(ref_id))?;
+        let event = plugin.build_event_to_send(
+            WindowContext::from_window(window),
+            &InternalEventPayload::CallHttpRequestActionRequest(req),
+            None,
+        );
+        plugin.send(&event).await?;
+        Ok(())
+    }
+
+    pub async fn call_template_function(
+        &self,
+        window_context: WindowContext,
+        fn_name: &str,
+        args: HashMap<String, String>,
+        purpose: RenderPurpose,
+    ) -> Result<Option<String>> {
+        let req = CallTemplateFunctionRequest {
+            name: fn_name.to_string(),
+            args: CallTemplateFunctionArgs {
+                purpose,
+                values: args,
+            },
+        };
+
+        let events = self
+            .send_and_wait(window_context, &InternalEventPayload::CallTemplateFunctionRequest(req))
+            .await?;
+
+        let value = events.into_iter().find_map(|e| match e.payload {
+            InternalEventPayload::CallTemplateFunctionResponse(CallTemplateFunctionResponse {
+                value,
+            }) => value,
+            _ => None,
+        });
+
+        Ok(value)
+    }
+
+    pub async fn import_data<R: Runtime>(
+        &self,
+        window: &WebviewWindow<R>,
+        content: &str,
+    ) -> Result<(ImportResponse, String)> {
+        let reply_events = self
+            .send_and_wait(
+                WindowContext::from_window(window),
+                &InternalEventPayload::ImportRequest(ImportRequest {
+                    content: content.to_string(),
+                }),
+            )
+            .await?;
+
+        // TODO: Don't just return the first valid response
+        let result = reply_events.into_iter().find_map(|e| match e.payload {
+            InternalEventPayload::ImportResponse(resp) => Some((resp, e.plugin_ref_id)),
+            _ => None,
+        });
+
+        match result {
+            None => Err(PluginErr("No importers found for file contents".to_string())),
+            Some((resp, ref_id)) => {
+                let plugin = self
+                    .get_plugin_by_ref_id(ref_id.as_str())
+                    .await
+                    .ok_or(PluginNotFoundErr(ref_id))?;
+                Ok((resp, plugin.info().await.name))
+            }
+        }
+    }
+
+    pub async fn filter_data<R: Runtime>(
+        &self,
+        window: &WebviewWindow<R>,
+        filter: &str,
+        content: &str,
+        content_type: &str,
+    ) -> Result<FilterResponse> {
+        let plugin_name = if content_type.to_lowercase().contains("json") {
+            "@yaakapp/filter-jsonpath"
+        } else {
+            "@yaakapp/filter-xpath"
+        };
+
+        let plugin = self
+            .get_plugin_by_name(plugin_name)
+            .await
+            .ok_or(PluginNotFoundErr(plugin_name.to_string()))?;
+
+        let event = self
+            .send_to_plugin_and_wait(
+                WindowContext::from_window(window),
+                &plugin,
+                &InternalEventPayload::FilterRequest(FilterRequest {
+                    filter: filter.to_string(),
+                    content: content.to_string(),
+                }),
+            )
+            .await?;
+
+        match event.payload {
+            InternalEventPayload::FilterResponse(resp) => Ok(resp),
+            InternalEventPayload::EmptyResponse => {
+                Err(PluginErr("Filter returned empty".to_string()))
+            }
+            e => Err(PluginErr(format!("Export returned invalid event {:?}", e))),
+        }
+    }
+}
+
+async fn read_plugins_dir(dir: &PathBuf) -> Result<Vec<String>> {
+    let mut result = read_dir(dir).await?;
+    let mut dirs: Vec<String> = vec![];
+    while let Ok(Some(entry)) = result.next_entry().await {
+        if entry.path().is_dir() {
+            #[cfg(target_os = "windows")]
+            dirs.push(fix_windows_paths(&entry.path()));
+            #[cfg(not(target_os = "windows"))]
+            dirs.push(entry.path().to_string_lossy().to_string());
+        }
+    }
+    Ok(dirs)
+}
+
+#[cfg(target_os = "windows")]
+fn fix_windows_paths(p: &PathBuf) -> String {
+    use dunce;
+    use path_slash::PathBufExt;
+    use regex::Regex;
+
+    // 1. Remove UNC prefix for Windows paths to pass to sidecar
+    let safe_path = dunce::simplified(p.as_path()).to_string_lossy().to_string();
+
+    // 2. Remove the drive letter
+    let safe_path = Regex::new("^[a-zA-Z]:").unwrap().replace(safe_path.as_str(), "");
+
+    // 3. Convert backslashes to forward
+    let safe_path = PathBuf::from(safe_path.to_string()).to_slash_lossy().to_string();
+
+    safe_path
+}

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

@@ -0,0 +1,72 @@
+use std::net::SocketAddr;
+use crate::error::Result;
+use log::info;
+use serde;
+use serde::Deserialize;
+use tauri::path::BaseDirectory;
+use tauri::{AppHandle, Manager, Runtime};
+use tauri_plugin_shell::process::CommandEvent;
+use tauri_plugin_shell::ShellExt;
+use tokio::sync::watch::Receiver;
+
+#[derive(Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+struct PortFile {
+    port: i32,
+}
+
+pub async fn start_nodejs_plugin_runtime<R: Runtime>(
+    app: &AppHandle<R>,
+    addr: SocketAddr,
+    kill_rx: &Receiver<bool>,
+) -> Result<()> {
+    let plugin_runtime_main = app
+        .path()
+        .resolve("vendored/plugin-runtime", BaseDirectory::Resource)?
+        .join("index.cjs");
+
+    // HACK: Remove UNC prefix for Windows paths to pass to sidecar
+    let plugin_runtime_main = dunce::simplified(plugin_runtime_main.as_path())
+        .to_string_lossy()
+        .to_string();
+
+    info!("Starting plugin runtime main={}", plugin_runtime_main);
+
+    let cmd = app
+        .shell()
+        .sidecar("yaaknode")?
+        .env("PORT", addr.port().to_string())
+        .args(&[plugin_runtime_main]);
+
+    let (mut child_rx, child) = cmd.spawn()?;
+    info!("Spawned plugin runtime");
+
+    let mut kill_rx = kill_rx.clone();
+
+    tokio::spawn(async move {
+        while let Some(event) = child_rx.recv().await {
+            match event {
+                CommandEvent::Stderr(line) => {
+                    print!("{}", String::from_utf8(line).unwrap());
+                }
+                CommandEvent::Stdout(line) => {
+                    print!("{}", String::from_utf8(line).unwrap());
+                }
+                _ => {}
+            }
+        }
+    });
+
+    // Check on child
+    tokio::spawn(async move {
+        kill_rx
+            .wait_for(|b| *b == true)
+            .await
+            .expect("Kill channel errored");
+        info!("Killing plugin runtime");
+        child.kill().expect("Failed to kill plugin runtime");
+        info!("Killed plugin runtime");
+    });
+
+    Ok(())
+}

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

@@ -0,0 +1,83 @@
+use crate::error::Result;
+use crate::events::{BootResponse, InternalEvent, InternalEventPayload, WindowContext};
+use crate::server::plugin_runtime::EventStreamEvent;
+use crate::util::gen_id;
+use log::info;
+use std::sync::Arc;
+use tokio::sync::{mpsc, Mutex};
+
+#[derive(Clone)]
+pub struct PluginHandle {
+    pub ref_id: String,
+    pub dir: String,
+    pub(crate) to_plugin_tx: Arc<Mutex<mpsc::Sender<tonic::Result<EventStreamEvent>>>>,
+    pub(crate) boot_resp: Arc<Mutex<BootResponse>>,
+}
+
+impl PluginHandle {
+    pub fn new(dir: &str, tx: mpsc::Sender<tonic::Result<EventStreamEvent>>) -> Self {
+        let ref_id = gen_id();
+
+        PluginHandle {
+            ref_id: ref_id.clone(),
+            dir: dir.to_string(),
+            to_plugin_tx: Arc::new(Mutex::new(tx)),
+            boot_resp: Arc::new(Mutex::new(BootResponse::default())),
+        }
+    }
+
+    pub async fn info(&self) -> BootResponse {
+        let resp = &*self.boot_resp.lock().await;
+        resp.clone()
+    }
+
+    pub fn build_event_to_send(
+        &self,
+        window_context: WindowContext,
+        payload: &InternalEventPayload,
+        reply_id: Option<String>,
+    ) -> InternalEvent {
+        self.build_event_to_send_raw(window_context, payload, reply_id)
+    }
+
+    pub(crate) fn build_event_to_send_raw(
+        &self,
+        window_context: WindowContext,
+        payload: &InternalEventPayload,
+        reply_id: Option<String>,
+    ) -> InternalEvent {
+        InternalEvent {
+            id: gen_id(),
+            plugin_ref_id: self.ref_id.clone(),
+            reply_id,
+            payload: payload.clone(),
+            window_context,
+        }
+    }
+
+    pub async fn terminate(&self, window_context: WindowContext) -> Result<()> {
+        info!("Terminating plugin {}", self.dir);
+        let event = self.build_event_to_send(
+            window_context,
+            &InternalEventPayload::TerminateRequest,
+            None,
+        );
+        self.send(&event).await
+    }
+
+    pub(crate) async fn send(&self, event: &InternalEvent) -> Result<()> {
+        self.to_plugin_tx
+            .lock()
+            .await
+            .send(Ok(EventStreamEvent {
+                event: serde_json::to_string(event)?,
+            }))
+            .await?;
+        Ok(())
+    }
+
+    pub async fn set_boot_response(&self, resp: &BootResponse) {
+        let mut boot_resp = self.boot_resp.lock().await;
+        *boot_resp = resp.clone();
+    }
+}

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

@@ -0,0 +1,99 @@
+use log::warn;
+use std::pin::Pin;
+use std::sync::Arc;
+use tokio::sync::{mpsc, Mutex};
+use tonic::codegen::tokio_stream::wrappers::ReceiverStream;
+use tonic::codegen::tokio_stream::{Stream, StreamExt};
+use tonic::{Request, Response, Status, Streaming};
+
+use crate::events::InternalEvent;
+use crate::server::plugin_runtime::plugin_runtime_server::PluginRuntime;
+use plugin_runtime::EventStreamEvent;
+
+pub mod plugin_runtime {
+    tonic::include_proto!("yaak.plugins.runtime");
+}
+
+type ResponseStream = Pin<Box<dyn Stream<Item = Result<EventStreamEvent, Status>> + Send>>;
+
+#[derive(Clone)]
+pub(crate) struct PluginRuntimeServerImpl {
+    pub(crate) app_to_plugin_events_tx:
+        Arc<Mutex<Option<mpsc::Sender<tonic::Result<EventStreamEvent>>>>>,
+    client_disconnect_tx: mpsc::Sender<bool>,
+    client_connect_tx: tokio::sync::watch::Sender<bool>,
+    plugin_to_app_events_tx: mpsc::Sender<InternalEvent>,
+}
+
+impl PluginRuntimeServerImpl {
+    pub fn new(
+        events_tx: mpsc::Sender<InternalEvent>,
+        disconnect_tx: mpsc::Sender<bool>,
+        connect_tx: tokio::sync::watch::Sender<bool>,
+    ) -> Self {
+        PluginRuntimeServerImpl {
+            app_to_plugin_events_tx: Arc::new(Mutex::new(None)),
+            client_disconnect_tx: disconnect_tx,
+            client_connect_tx: connect_tx,
+            plugin_to_app_events_tx: events_tx,
+        }
+    }
+}
+
+#[tonic::async_trait]
+impl PluginRuntime for PluginRuntimeServerImpl {
+    type EventStreamStream = ResponseStream;
+
+    async fn event_stream(
+        &self,
+        req: Request<Streaming<EventStreamEvent>>,
+    ) -> tonic::Result<Response<Self::EventStreamStream>> {
+        let mut in_stream = req.into_inner();
+
+        let (to_plugin_tx, to_plugin_rx) = mpsc::channel::<tonic::Result<EventStreamEvent>>(128);
+        let mut app_to_plugin_events_tx = self.app_to_plugin_events_tx.lock().await;
+        *app_to_plugin_events_tx = Some(to_plugin_tx);
+
+        let plugin_to_app_events_tx = self.plugin_to_app_events_tx.clone();
+        let client_disconnect_tx = self.client_disconnect_tx.clone();
+
+        self.client_connect_tx.send(true).expect("Failed to send client ready event");
+
+        tokio::spawn(async move {
+            while let Some(result) = in_stream.next().await {
+                // Received event from plugin runtime
+                match result {
+                    Ok(v) => {
+                        let event: InternalEvent = match serde_json::from_str(v.event.as_str()) {
+                            Ok(pe) => pe,
+                            Err(e) => {
+                                warn!("Failed to deserialize event {e:?} -> {}", v.event);
+                                continue;
+                            }
+                        };
+
+                        // Send event to subscribers
+                        // Emit event to the channel for server to handle
+                        if let Err(e) = plugin_to_app_events_tx.try_send(event.clone()) {
+                            warn!("Failed to send to channel. Receiver probably isn't listening: {:?}", e);
+                        }
+                    }
+                    Err(err) => {
+                        // TODO: Better error handling
+                        warn!("gRPC server error {err}");
+                        break;
+                    }
+                };
+            }
+
+            if let Err(e) = client_disconnect_tx.send(true).await {
+                warn!("Failed to send killed event {:?}", e);
+            }
+        });
+
+        // Write the same data that was received
+        let out_stream = ReceiverStream::new(to_plugin_rx);
+
+        Ok(Response::new(Box::pin(out_stream) as Self::EventStreamStream))
+    }
+}

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

@@ -0,0 +1,5 @@
+use rand::distributions::{Alphanumeric, DistString};
+
+pub fn gen_id() -> String {
+    Alphanumeric.sample_string(&mut rand::thread_rng(), 5)
+}