Struct PluginManager 

pub struct PluginManager { /* private fields */ }

Unified plugin manager that abstracts over the plugin system.

When the plugins feature is enabled, this wraps PluginThreadHandle. When disabled, all methods are no-ops.

Implementations

impl PluginManager

pub fn new( enable: bool, command_registry: Arc<RwLock<CommandRegistry>>, dir_context: DirectoryContext, theme_cache: Arc<RwLock<HashMap<String, Value>>>, ) -> Self

Create a new plugin manager.

When plugins feature is enabled and enable is true, spawns the plugin thread. Otherwise, creates a no-op manager.

pub fn is_active(&self) -> bool

Check if the plugin system is active (has a running plugin thread).

pub fn is_alive(&self) -> bool

Check if the plugin thread is still alive

pub fn check_thread_health(&mut self)

Check thread health and panic if the plugin thread died due to a panic. This propagates plugin thread panics to the calling thread. Call this periodically (e.g., in wait loops) to fail fast on plugin errors.

pub fn load_plugins_from_dir(&self, dir: &Path) -> Vec<String>

Load plugins from a directory.

pub fn load_plugins_from_dir_with_config( &self, dir: &Path, plugin_configs: &HashMap<String, PluginConfig>, ) -> (Vec<String>, HashMap<String, PluginConfig>)

Load plugins from a directory with config support. Returns (errors, discovered_plugins) where discovered_plugins is a map of plugin name -> PluginConfig with paths populated.

pub fn unload_plugin(&self, name: &str) -> Result<()>

Unload a plugin by name.

pub fn load_plugin(&self, path: &Path) -> Result<()>

Load a single plugin by path.

pub fn load_plugin_from_source( &self, source: &str, name: &str, is_typescript: bool, ) -> Result<()>

Load a plugin from source code directly (no file I/O).

If a plugin with the same name is already loaded, it will be unloaded first (hot-reload semantics). This is used for “Load Plugin from Buffer”.

pub fn run_hook(&self, hook_name: &str, args: HookArgs)

Run a hook (fire-and-forget).

pub fn deliver_response(&self, response: PluginResponse)

Deliver a response to a pending async plugin operation.

pub fn process_commands(&mut self) -> Vec<PluginCommand>

Process pending plugin commands (non-blocking).

pub fn process_commands_until_hook_completed( &mut self, hook_name: &str, timeout: Duration, ) -> Vec<PluginCommand>

Process commands, blocking until HookCompleted for the given hook arrives. See PluginThreadHandle::process_commands_until_hook_completed for details.

pub fn state_snapshot_handle(&self) -> Option<Arc<RwLock<EditorStateSnapshot>>>

Get the state snapshot handle for updating editor state.

pub fn execute_action_async( &self, action_name: &str, ) -> Option<Result<Receiver<Result<()>>>>

Execute a plugin action asynchronously.

pub fn list_plugins(&self) -> Vec<TsPluginInfo>

List all loaded plugins.

pub fn reload_plugin(&self, name: &str) -> Result<()>

Reload a plugin by name.

pub fn has_hook_handlers(&self, hook_name: &str) -> bool

Check if any handlers are registered for a hook.

pub fn resolve_callback(&self, callback_id: JsCallbackId, result_json: String)

Resolve an async callback in the plugin runtime

pub fn reject_callback(&self, callback_id: JsCallbackId, error: String)

Reject an async callback in the plugin runtime

pub fn call_streaming_callback( &self, callback_id: JsCallbackId, result_json: String, done: bool, )

Call a streaming callback with partial data (does not consume the callback). When done is true, the JS side cleans up.