chore(owlry-rune): bump version to 1.1.1

:config and :conv were not in the prefix lists, so typing them
showed 'Plugin' mode but didn't route to the config/converter
providers. Also added :settings, :converter aliases.

.gitignore

@@ -1,8 +1,10 @@
 /target
 CLAUDE.md
+.worktrees/
 media.md
 
 # AUR packages (each is its own git repo for aur.archlinux.org)
+# Track PKGBUILD and .SRCINFO, ignore build artifacts and sub-repo .git
 aur/*/.git/
 aur/*/pkg/
 aur/*/src/
@@ -10,6 +12,3 @@ aur/*/*.tar.zst
 aur/*/*.tar.gz
 aur/*/*.tar.xz
 aur/*/*.pkg.tar.*
-# Keep PKGBUILD and .SRCINFO tracked
-.SRCINFO
-aur/

CLAUDE.md

@@ -0,0 +1,439 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build & Development Commands
+
+```bash
+just build          # Debug build (all workspace members)
+just build-ui       # UI binary only
+just build-daemon   # Core daemon only
+just release        # Release build (LTO, stripped)
+just release-daemon # Release build for daemon only
+just check          # cargo check + clippy
+just test           # Run tests
+just fmt            # Format code
+just run [ARGS]     # Run UI with optional args (e.g., just run --mode app)
+just run-daemon     # Run core daemon
+just install-local  # Install core + daemon + runtimes + systemd units
+
+# Dev build with verbose logging
+cargo run -p owlry --features dev-logging
+
+# Build core without embedded Lua (smaller binary, uses external owlry-lua)
+cargo build -p owlry --release --no-default-features
+```
+
+## Usage Examples
+
+### Basic Invocation
+
+The UI client connects to the `owlry-core` daemon via Unix socket IPC. Start the daemon first:
+
+```bash
+# Start daemon (systemd recommended)
+systemctl --user enable --now owlry-core.service
+
+# Or run directly
+owlry-core
+
+# Then launch UI
+owlry                      # Launch with all providers
+owlry -m app               # Applications only
+owlry -m cmd               # PATH commands only
+owlry --profile dev        # Use a named config profile
+owlry -m calc              # Calculator plugin only (if installed)
+```
+
+### dmenu Mode
+
+dmenu mode runs locally without the daemon. Use `-m dmenu` with piped input for interactive selection. The selected item is printed to stdout (not executed), so pipe the output to execute it:
+
+```bash
+# Screenshot menu (execute selected command)
+printf '%s\n' \
+  "grimblast --notify copy screen" \
+  "grimblast --notify copy area" \
+  "grimblast --notify edit screen" \
+  | owlry -m dmenu -p "Screenshot" \
+  | sh
+
+# Git branch checkout
+git branch | owlry -m dmenu -p "checkout" | xargs git checkout
+
+# Kill a process
+ps -eo comm | sort -u | owlry -m dmenu -p "kill" | xargs pkill
+
+# Select and open a project
+find ~/projects -maxdepth 1 -type d | owlry -m dmenu | xargs code
+```
+
+### CLI Flags
+
+| Flag | Description |
+|------|-------------|
+| `-m`, `--mode MODE` | Start in single-provider mode (app, cmd, dmenu, calc, etc.) |
+| `--profile NAME` | Use a named profile from config (defines which modes to enable) |
+| `-p`, `--prompt TEXT` | Custom prompt text for the search input (dmenu mode) |
+
+### Available Modes
+
+| Mode | Description |
+|------|-------------|
+| `app` | Desktop applications |
+| `cmd` | PATH commands |
+| `dmenu` | Pipe-based selection (requires stdin, runs locally) |
+| `calc` | Calculator (plugin) |
+| `clip` | Clipboard history (plugin) |
+| `emoji` | Emoji picker (plugin) |
+| `ssh` | SSH hosts (plugin) |
+| `sys` | System actions (plugin) |
+| `bm` | Bookmarks (plugin) |
+| `file` | File search (plugin) |
+| `web` | Web search (plugin) |
+| `uuctl` | systemd user units (plugin) |
+
+### Search Prefixes
+
+Type these in the search box to filter by provider:
+
+| Prefix | Provider | Example |
+|--------|----------|---------|
+| `:app` | Applications | `:app firefox` |
+| `:cmd` | PATH commands | `:cmd git` |
+| `:sys` | System actions | `:sys shutdown` |
+| `:ssh` | SSH hosts | `:ssh server` |
+| `:clip` | Clipboard | `:clip password` |
+| `:bm` | Bookmarks | `:bm github` |
+| `:emoji` | Emoji | `:emoji heart` |
+| `:calc` | Calculator | `:calc sqrt(16)` |
+| `:web` | Web search | `:web rust docs` |
+| `:file` | Files | `:file config` |
+| `:uuctl` | systemd | `:uuctl docker` |
+| `:tag:X` | Filter by tag | `:tag:development` |
+
+### Trigger Prefixes
+
+| Trigger | Provider | Example |
+|---------|----------|---------|
+| `=` | Calculator | `= 5+3` |
+| `?` | Web search | `? rust programming` |
+| `/` | File search | `/ .bashrc` |
+
+### Keyboard Shortcuts
+
+| Key | Action |
+|-----|--------|
+| `Enter` | Launch selected item |
+| `Escape` | Close launcher / exit submenu |
+| `Up` / `Down` | Navigate results |
+| `Tab` | Cycle filter tabs |
+| `Shift+Tab` | Cycle tabs (reverse) |
+| `Ctrl+1..9` | Toggle tab by position |
+
+### Plugin CLI
+
+```bash
+owlry plugin list                  # List installed
+owlry plugin list --available      # Show registry
+owlry plugin search "query"        # Search registry
+owlry plugin install <name>        # Install from registry
+owlry plugin install ./path        # Install from local path
+owlry plugin remove <name>         # Uninstall
+owlry plugin enable/disable <name> # Toggle
+owlry plugin create <name>         # Create Lua plugin template
+owlry plugin create <name> -r rune # Create Rune plugin template
+owlry plugin validate ./path       # Validate plugin structure
+owlry plugin run <id> <cmd> [args] # Run plugin CLI command
+owlry plugin commands <id>         # List plugin commands
+owlry plugin runtimes              # Show available runtimes
+```
+
+## Release Workflow
+
+Always use `just` for releases - do NOT manually edit Cargo.toml for version bumps:
+
+```bash
+# Bump a single crate
+just bump-crate owlry-core 0.5.1
+
+# Bump all crates to same version
+just bump-all 0.5.1
+
+# Bump core UI only
+just bump 0.5.1
+
+# Create and push release tag
+git push && just tag
+
+# Tagging convention: every crate gets its own tag
+# Format: {crate-name}-v{version}
+# Examples:
+#   owlry-v1.0.1
+#   owlry-core-v1.1.0
+#   owlry-lua-v1.1.0
+#   owlry-rune-v1.1.0
+#   plugin-api-v1.0.1
+#
+# The plugins repo uses the same convention:
+#   owlry-plugin-bookmarks-v1.0.1
+#   owlry-plugin-calculator-v1.0.1
+#   etc.
+#
+# IMPORTANT: After bumping versions, tag EVERY changed crate individually.
+# The plugin-api tag is referenced by owlry-plugins Cargo.toml as a git dependency.
+
+# AUR package management
+just aur-update           # Update core UI PKGBUILD
+just aur-update-pkg NAME  # Update specific package (owlry-core, owlry-lua, etc.)
+just aur-update-all       # Update all AUR packages
+just aur-publish          # Publish core UI to AUR
+just aur-publish-all      # Publish all AUR packages
+
+# Version inspection
+just show-versions        # List all crate versions
+just aur-status           # Show AUR package versions and git status
+```
+
+## AUR Packaging
+
+The `aur/` directory contains PKGBUILDs for core packages:
+
+| Category | Packages |
+|----------|----------|
+| Core UI | `owlry` |
+| Core Daemon | `owlry-core` |
+| Runtimes | `owlry-lua`, `owlry-rune` |
+| Meta-bundles | `owlry-meta-essentials`, `owlry-meta-widgets`, `owlry-meta-tools`, `owlry-meta-full` |
+
+Plugin AUR packages are in the separate `owlry-plugins` repo at `somegit.dev/Owlibou/owlry-plugins`.
+
+## Architecture
+
+### Client/Daemon Split
+
+Owlry uses a client/daemon architecture:
+
+- **`owlry`** (client): GTK4 UI that connects to the daemon via Unix socket IPC. Handles rendering, user input, and launching applications. In dmenu mode, runs a local `ProviderManager` directly (no daemon needed).
+- **`owlry-core`** (daemon): Headless background service that loads plugins, manages providers, handles fuzzy matching, frecency scoring, and serves queries over IPC. Runs as a systemd user service.
+
+### Workspace Structure
+
+```
+owlry/
+├── Cargo.toml                      # Workspace root
+├── systemd/                        # systemd user service/socket files
+│   ├── owlry-core.service
+│   └── owlry-core.socket
+├── crates/
+│   ├── owlry/                      # UI client binary (GTK4 + Layer Shell)
+│   │   └── src/
+│   │       ├── main.rs             # Entry point
+│   │       ├── app.rs              # GTK Application setup, CSS loading
+│   │       ├── cli.rs              # Clap CLI argument parsing
+│   │       ├── client.rs           # CoreClient - IPC client to daemon
+│   │       ├── backend.rs          # SearchBackend - abstraction over IPC/local
+│   │       ├── theme.rs            # Theme loading
+│   │       ├── plugin_commands.rs  # Plugin CLI subcommand handlers
+│   │       ├── providers/          # dmenu provider (local-only)
+│   │       └── ui/                 # GTK widgets (MainWindow, ResultRow, submenu)
+│   ├── owlry-core/                 # Daemon library + binary
+│   │   └── src/
+│   │       ├── main.rs             # Daemon entry point
+│   │       ├── lib.rs              # Public API (re-exports modules)
+│   │       ├── server.rs           # Unix socket IPC server
+│   │       ├── ipc.rs              # Request/Response message types
+│   │       ├── filter.rs           # ProviderFilter - mode/prefix filtering
+│   │       ├── paths.rs            # XDG path utilities, socket path
+│   │       ├── notify.rs           # Desktop notifications
+│   │       ├── config/             # Config loading (config.toml)
+│   │       ├── data/               # FrecencyStore
+│   │       ├── providers/          # Application, Command, native/lua provider hosts
+│   │       └── plugins/            # Plugin loading, manifests, registry, runtimes
+│   ├── owlry-plugin-api/           # ABI-stable plugin interface
+│   ├── owlry-lua/                  # Lua script runtime (cdylib)
+│   └── owlry-rune/                 # Rune script runtime (cdylib)
+```
+
+### IPC Protocol
+
+Communication uses newline-delimited JSON over a Unix domain socket at `$XDG_RUNTIME_DIR/owlry/owlry.sock`.
+
+**Request types** (`owlry_core::ipc::Request`):
+
+| Type | Purpose |
+|------|---------|
+| `Query` | Search with text and optional mode filters |
+| `Launch` | Record a launch event for frecency |
+| `Providers` | List available providers |
+| `Refresh` | Refresh a specific provider |
+| `Toggle` | Toggle visibility (client-side concern, daemon acks) |
+| `Submenu` | Query submenu actions for a plugin item |
+| `PluginAction` | Execute a plugin action command |
+
+**Response types** (`owlry_core::ipc::Response`):
+
+| Type | Purpose |
+|------|---------|
+| `Results` | Search results with `Vec<ResultItem>` |
+| `Providers` | Provider list with `Vec<ProviderDesc>` |
+| `SubmenuItems` | Submenu actions for a plugin |
+| `Ack` | Success acknowledgement |
+| `Error` | Error with message |
+
+### Core Data Flow
+
+```
+[owlry UI]                              [owlry-core daemon]
+
+main.rs → CliArgs → OwlryApp            main.rs → Server::bind()
+         ↓                                         ↓
+    SearchBackend                        UnixListener accept loop
+         ↓                                         ↓
+  ┌──────┴──────┐                        handle_request()
+  ↓             ↓                              ↓
+Daemon       Local (dmenu)         ┌───────────┴───────────┐
+  ↓                                ↓                       ↓
+CoreClient ──── IPC ────→   ProviderManager         ProviderFilter
+                                   ↓                       ↓
+                         [Provider impls]         parse_query()
+                                   ↓
+                            LaunchItem[]
+                                   ↓
+                         FrecencyStore (boost)
+                                   ↓
+                         Response::Results ──── IPC ────→ UI rendering
+```
+
+### Provider System
+
+**Core providers** (in `owlry-core`):
+- **Application**: Desktop applications from XDG directories
+- **Command**: Shell commands from PATH
+
+**dmenu provider** (in `owlry` client, local only):
+- **Dmenu**: Pipe-based input (dmenu compatibility)
+
+All other providers are native plugins in the separate `owlry-plugins` repo (`somegit.dev/Owlibou/owlry-plugins`).
+
+**User plugins** (script-based, in `~/.config/owlry/plugins/`):
+- **Lua plugins**: Loaded by `owlry-lua` runtime from `/usr/lib/owlry/runtimes/liblua.so`
+- **Rune plugins**: Loaded by `owlry-rune` runtime from `/usr/lib/owlry/runtimes/librune.so`
+- User plugins are **hot-reloaded** automatically when files change (no daemon restart needed)
+- Custom prefixes (e.g., `:hs`) are resolved dynamically for user plugins
+
+`ProviderManager` (in `owlry-core`) orchestrates providers and handles:
+- Fuzzy matching via `SkimMatcherV2`
+- Frecency score boosting
+- Native plugin loading from `/usr/lib/owlry/plugins/`
+- Script runtime loading from `/usr/lib/owlry/runtimes/` for user plugins
+- Filesystem watching for automatic user plugin hot-reload
+
+**Submenu System**: Plugins can return items with `SUBMENU:plugin_id:data` commands. When selected, the plugin is queried with `?SUBMENU:data` to get action items (e.g., systemd service actions).
+
+### Plugin API
+
+Native plugins use the ABI-stable interface in `owlry-plugin-api`:
+
+```rust
+#[repr(C)]
+pub struct PluginVTable {
+    pub info: extern "C" fn() -> PluginInfo,
+    pub providers: extern "C" fn() -> RVec<ProviderInfo>,
+    pub provider_init: extern "C" fn(id: RStr) -> ProviderHandle,
+    pub provider_refresh: extern "C" fn(ProviderHandle) -> RVec<PluginItem>,
+    pub provider_query: extern "C" fn(ProviderHandle, RStr) -> RVec<PluginItem>,
+    pub provider_drop: extern "C" fn(ProviderHandle),
+}
+
+// Each plugin exports:
+#[no_mangle]
+pub extern "C" fn owlry_plugin_vtable() -> &'static PluginVTable
+```
+
+Plugins are compiled as `.so` (cdylib) and loaded by the daemon at startup.
+
+**Plugin locations** (when deployed):
+- `/usr/lib/owlry/plugins/*.so` - Native plugins
+- `/usr/lib/owlry/runtimes/*.so` - Script runtimes (liblua.so, librune.so)
+- `~/.config/owlry/plugins/` - User plugins (Lua/Rune)
+
+### Filter & Prefix System
+
+`ProviderFilter` (`owlry-core/src/filter.rs`) handles:
+- CLI mode selection (`--mode app`)
+- Profile-based mode selection (`--profile dev`)
+- Provider toggling (Ctrl+1/2/3)
+- Prefix parsing (`:app`, `:cmd`, `:sys`, etc.)
+- Dynamic prefix fallback for user plugins (any `:word` prefix maps to `Plugin(word)`)
+
+Query parsing extracts prefix and forwards clean query to providers.
+
+### SearchBackend
+
+`SearchBackend` (`owlry/src/backend.rs`) abstracts over two modes:
+- **`Daemon`**: Wraps `CoreClient`, sends queries over IPC to `owlry-core`
+- **`Local`**: Wraps `ProviderManager` directly (used for dmenu mode only)
+
+### UI Layer
+
+- `MainWindow` (`src/ui/main_window.rs`): GTK4 window with Layer Shell overlay
+- `ResultRow` (`src/ui/result_row.rs`): Individual result rendering
+- `submenu` (`src/ui/submenu.rs`): Universal submenu parsing utilities (plugins provide actions)
+
+### Configuration
+
+`Config` (`owlry-core/src/config/mod.rs`) loads from `~/.config/owlry/config.toml`:
+- Auto-detects terminal (`$TERMINAL` -> `xdg-terminal-exec` -> common terminals)
+- Optional `use_uwsm = true` for systemd session integration (launches apps via `uwsm app --`)
+- Profiles: Define named mode sets under `[profiles.<name>]` with `modes = ["app", "cmd", ...]`
+
+### Theming
+
+CSS loading priority (`owlry/src/app.rs`):
+1. Base structural CSS (`resources/base.css`)
+2. Theme CSS (built-in "owl" or custom `~/.config/owlry/themes/{name}.css`)
+3. User overrides (`~/.config/owlry/style.css`)
+4. Config variable injection
+
+### Systemd Integration
+
+Service files in `systemd/`:
+- `owlry-core.service`: Runs daemon as `Type=simple`, restarts on failure
+- `owlry-core.socket`: Socket activation at `%t/owlry/owlry.sock`
+
+Start with: `systemctl --user enable --now owlry-core.service`
+
+## Plugins
+
+Plugins live in a separate repository: `somegit.dev/Owlibou/owlry-plugins`
+
+13 native plugin crates, all compiled as cdylib (.so):
+
+| Category | Plugins | Behavior |
+|----------|---------|----------|
+| Static | bookmarks, clipboard, emoji, scripts, ssh, system, systemd | Loaded at startup, refresh() populates items |
+| Dynamic | calculator, websearch, filesearch | Queried per-keystroke via query() |
+| Widget | weather, media, pomodoro | Displayed at top of results |
+
+## Key Patterns
+
+- **Rc<RefCell<T>>** used throughout for GTK signal handlers needing mutable state
+- **Feature flag `dev-logging`**: Wraps debug!() calls in `#[cfg(feature = "dev-logging")]`
+- **Feature flag `lua`**: Enables built-in Lua runtime (off by default); enable to embed Lua in core binary
+- **Script runtimes**: External `.so` runtimes loaded from `/usr/lib/owlry/runtimes/` — Lua and Rune user plugins loaded from `~/.config/owlry/plugins/`
+- **Hot-reload**: Filesystem watcher (`notify` crate) monitors user plugins dir and reloads runtimes on file changes
+- **dmenu mode**: Runs locally without daemon. Use `-m dmenu` with piped stdin
+- **Frecency**: Time-decayed frequency scoring stored in `~/.local/share/owlry/frecency.json`
+- **ABI stability**: Plugin interface uses `abi_stable` crate for safe Rust dynamic linking
+- **Plugin API v3**: Adds `position` (Normal/Widget) and `priority` fields to ProviderInfo
+- **ProviderType simplification**: Core uses only `Application`, `Command`, `Dmenu`, `Plugin(String)` - all plugin-specific types removed from core
+
+## Dependencies (Rust 1.90+, GTK 4.12+)
+
+External tool dependencies (for plugins):
+- Clipboard plugin: `cliphist`, `wl-clipboard`
+- File search plugin: `fd` or `mlocate`
+- Emoji plugin: `wl-clipboard`, `noto-fonts-emoji`
+- Systemd plugin: `systemd` (user services)
+- Bookmarks plugin: Firefox support uses `rusqlite` with bundled SQLite (no system dependency)

Cargo.toml

@@ -2,20 +2,8 @@
 resolver = "2"
 members = [
     "crates/owlry",
+    "crates/owlry-core",
     "crates/owlry-plugin-api",
-    "crates/owlry-plugin-calculator",
-    "crates/owlry-plugin-system",
-    "crates/owlry-plugin-ssh",
-    "crates/owlry-plugin-clipboard",
-    "crates/owlry-plugin-emoji",
-    "crates/owlry-plugin-scripts",
-    "crates/owlry-plugin-bookmarks",
-    "crates/owlry-plugin-websearch",
-    "crates/owlry-plugin-filesearch",
-    "crates/owlry-plugin-weather",
-    "crates/owlry-plugin-media",
-    "crates/owlry-plugin-pomodoro",
-    "crates/owlry-plugin-systemd",
     "crates/owlry-lua",
     "crates/owlry-rune",
 ]

README.md

@@ -10,14 +10,19 @@ A lightweight, owl-themed application launcher for Wayland, built with GTK4 and
 
 ## Features
 
-- **Modular plugin architecture** — Install only what you need
-- **Fuzzy search with tags** — Fast matching across names, descriptions, and category tags
-- **13 native plugins** — Calculator, clipboard, emoji, weather, media, and more
+- **Client/daemon architecture** — Instant window appearance, providers stay loaded in memory
+- **Built-in providers** — Calculator, unit/currency converter, and system actions out of the box
+- **Built-in settings editor** — Configure everything from within the launcher (`:config`)
+- **11 optional plugins** — Clipboard, emoji, weather, media, bookmarks, and more
 - **Widget providers** — Weather, media controls, and pomodoro timer at the top of results
-- **Filter prefixes** — Scope searches with `:app`, `:cmd`, `:tag:development`, etc.
+- **Fuzzy search with tags** — Fast matching across names, descriptions, and category tags
+- **Config profiles** — Named mode presets for different workflows
+- **Filter prefixes** — Scope searches with `:app`, `:cmd`, `:config`, `:tag:X`, etc.
 - **Frecency ranking** — Frequently/recently used items rank higher
-- **GTK4 theming** — System theme by default, with 9 built-in themes
+- **Toggle behavior** — Bind one key to open/close the launcher
+- **GTK4 theming** — System theme by default, with 10 built-in themes
 - **Wayland native** — Uses Layer Shell for proper overlay behavior
+- **dmenu compatible** — Pipe-based selection mode, no daemon required
 - **Extensible** — Create custom plugins in Lua or Rune
 
 ## Installation
@@ -25,41 +30,45 @@ A lightweight, owl-themed application launcher for Wayland, built with GTK4 and
 ### Arch Linux (AUR)
 
 ```bash
-# Minimal core (applications + commands only)
+# Core (includes calculator, converter, system actions, settings editor)
 yay -S owlry
 
-# Add individual plugins
-yay -S owlry-plugin-calculator owlry-plugin-weather
+# Add individual plugins as needed
+yay -S owlry-plugin-bookmarks owlry-plugin-weather owlry-plugin-clipboard
 
-# Or install bundles:
-yay -S owlry-meta-essentials  # calculator, system, ssh, scripts, bookmarks
-yay -S owlry-meta-widgets     # weather, media, pomodoro
-yay -S owlry-meta-tools       # clipboard, emoji, websearch, filesearch, systemd
-yay -S owlry-meta-full        # everything
-
-# For custom Lua/Rune plugins
+# For custom Lua/Rune user plugins
 yay -S owlry-lua   # Lua 5.4 runtime
 yay -S owlry-rune  # Rune runtime
 ```
 
 ### Available Packages
 
+**Core packages** (this repo):
+
 | Package | Description |
 |---------|-------------|
-| `owlry` | Core binary with applications and commands |
-| `owlry-plugin-calculator` | Math expressions (`= 5+3`) |
-| `owlry-plugin-system` | Shutdown, reboot, suspend, lock |
-| `owlry-plugin-ssh` | SSH hosts from `~/.ssh/config` |
+| `owlry` | GTK4 UI client |
+| `owlry-core` | Daemon (`owlryd`) with built-in calculator, converter, system, and settings providers |
+| `owlry-lua` | Lua 5.4 script runtime for user plugins |
+| `owlry-rune` | Rune script runtime for user plugins |
+
+**Plugin packages** ([owlry-plugins](https://somegit.dev/Owlibou/owlry-plugins) repo):
+
+| Package | Description |
+|---------|-------------|
+| `owlry-plugin-bookmarks` | Firefox, Chrome, Brave, Edge bookmarks |
 | `owlry-plugin-clipboard` | History via cliphist |
 | `owlry-plugin-emoji` | 400+ searchable emoji |
-| `owlry-plugin-scripts` | User scripts |
-| `owlry-plugin-bookmarks` | Firefox, Chrome, Brave, Edge bookmarks |
-| `owlry-plugin-websearch` | Web search (`? query`) |
 | `owlry-plugin-filesearch` | File search (`/ filename`) |
-| `owlry-plugin-systemd` | User services with actions |
-| `owlry-plugin-weather` | Weather widget |
 | `owlry-plugin-media` | MPRIS media controls |
 | `owlry-plugin-pomodoro` | Pomodoro timer widget |
+| `owlry-plugin-scripts` | User scripts |
+| `owlry-plugin-ssh` | SSH hosts from `~/.ssh/config` |
+| `owlry-plugin-systemd` | User services with actions |
+| `owlry-plugin-weather` | Weather widget |
+| `owlry-plugin-websearch` | Web search (`? query`) |
+
+> **Note:** Calculator, converter, and system actions are built into `owlry-core` and do not require separate packages.
 
 ### Build from Source
 
@@ -80,58 +89,152 @@ sudo dnf install gtk4-devel gtk4-layer-shell-devel
 git clone https://somegit.dev/Owlibou/owlry.git
 cd owlry
 
-# Build core only
-cargo build --release -p owlry
+# Build daemon + UI
+cargo build --release -p owlry -p owlry-core
 
-# Build specific plugin
-cargo build --release -p owlry-plugin-calculator
+# Build runtimes (for user plugins)
+cargo build --release -p owlry-lua -p owlry-rune
 
-# Build everything
+# Build everything in this workspace
 cargo build --release --workspace
 ```
 
-**Install plugins manually:**
+**Plugins** are in a [separate repo](https://somegit.dev/Owlibou/owlry-plugins):
 ```bash
-sudo mkdir -p /usr/lib/owlry/plugins
-sudo cp target/release/libowlry_plugin_*.so /usr/lib/owlry/plugins/
+git clone https://somegit.dev/Owlibou/owlry-plugins.git
+cd owlry-plugins
+cargo build --release -p owlry-plugin-bookmarks  # or any plugin
 ```
 
+**Install locally:**
+```bash
+just install-local
+```
+
+This installs the UI (`owlry`), daemon (`owlryd`), runtimes, and systemd service files.
+
+## Getting Started
+
+Owlry uses a client/daemon architecture. The daemon (`owlryd`) loads providers and plugins into memory. The UI client (`owlry`) connects to the daemon over a Unix socket for instant results.
+
+### Starting the Daemon
+
+Choose one of three methods:
+
+**1. Compositor autostart (recommended for most users)**
+
+Add to your compositor config:
+
+```bash
+# Hyprland (~/.config/hypr/hyprland.conf)
+exec-once = owlryd
+
+# Sway (~/.config/sway/config)
+exec owlryd
+```
+
+**2. Systemd user service**
+
+```bash
+systemctl --user enable --now owlryd.service
+```
+
+**3. Socket activation (auto-start on first use)**
+
+```bash
+systemctl --user enable owlryd.socket
+```
+
+The daemon starts automatically when the UI client first connects.
+
+### Launching the UI
+
+Bind `owlry` to a key in your compositor:
+
+```bash
+# Hyprland
+bind = SUPER, Space, exec, owlry
+
+# Sway
+bindsym $mod+space exec owlry
+```
+
+Running `owlry` a second time while it is already open sends a toggle command — the window closes. A single keybind acts as open/close.
+
+If the daemon is not running when the UI launches, it will attempt to start it via systemd automatically.
+
 ## Usage
 
 ```bash
 owlry                      # Launch with all providers
 owlry -m app               # Applications only
 owlry -m cmd               # PATH commands only
-owlry -p app,cmd           # Multiple specific providers
-owlry -m calc              # Calculator plugin only (if installed)
+owlry -m calc              # Calculator only
+owlry --profile dev        # Use a named profile from config
 owlry --help               # Show all options with examples
 ```
 
-### dmenu Mode
+### Profiles
 
-Owlry is dmenu-compatible. Pipe input for interactive selection:
+Profiles are named sets of modes defined in your config:
+
+```toml
+[profiles.dev]
+modes = ["app", "cmd", "ssh"]
+
+[profiles.media]
+modes = ["media", "emoji"]
+
+[profiles.minimal]
+modes = ["app"]
+```
+
+Launch with a profile:
 
 ```bash
-# Basic selection
-echo -e "Option A\nOption B\nOption C" | owlry -m dmenu
+owlry --profile dev
+```
 
-# Select from files
-ls ~/Documents | owlry -m dmenu
+You can bind different profiles to different keys:
+
+```bash
+# Hyprland
+bind = SUPER, Space, exec, owlry
+bind = SUPER, D, exec, owlry --profile dev
+bind = SUPER, M, exec, owlry --profile media
+```
+
+Profiles can also be managed from the launcher itself — see [Settings Editor](#settings-editor).
+
+### dmenu Mode
+
+Owlry is dmenu-compatible. Pipe input for interactive selection — the selected item is printed to stdout (not executed), so you pipe the output to execute it.
+
+dmenu mode is self-contained: it does not use the daemon and works without `owlryd` running.
+
+```bash
+# Screenshot menu
+printf '%s\n' \
+  "grimblast --notify copy screen" \
+  "grimblast --notify copy area" \
+  "grimblast --notify edit screen" \
+  | owlry -m dmenu -p "Screenshot" \
+  | sh
 
 # Git branch checkout
-git branch | owlry -m dmenu --prompt "checkout:" | xargs git checkout
+git branch | owlry -m dmenu -p "checkout" | xargs git checkout
 
 # Kill a process
-ps -eo comm | sort -u | owlry -m dmenu --prompt "kill:" | xargs pkill
+ps -eo comm | sort -u | owlry -m dmenu -p "kill" | xargs pkill
 
 # Select and open a project
 find ~/projects -maxdepth 1 -type d | owlry -m dmenu | xargs code
 
 # Package manager search
-pacman -Ssq | owlry -m dmenu --prompt "install:" | xargs sudo pacman -S
+pacman -Ssq | owlry -m dmenu -p "install" | xargs sudo pacman -S
 ```
 
-The `--prompt` flag sets a custom label for the search input.
+The `-p` / `--prompt` flag sets a custom label for the search input.
 
 ### Keyboard Shortcuts
 
@@ -144,6 +247,24 @@ The `--prompt` flag sets a custom label for the search input.
 | `Shift+Tab` | Cycle filter tabs (reverse) |
 | `Ctrl+1..9` | Toggle tab by position |
 
+### Settings Editor
+
+Type `:config` to browse and modify settings without editing files:
+
+| Command | What it does |
+|---------|-------------|
+| `:config` | Show all setting categories |
+| `:config providers` | Toggle providers on/off |
+| `:config theme` | Select color theme |
+| `:config engine` | Select web search engine |
+| `:config frecency` | Toggle frecency, set weight |
+| `:config fontsize 16` | Set font size (restart to apply) |
+| `:config profiles` | List profiles |
+| `:config profile create dev` | Create a new profile |
+| `:config profile dev modes` | Edit which modes a profile includes |
+
+Changes are saved to `config.toml` immediately. Some settings (theme, frecency) take effect on the next search. Others (font size, dimensions) require a restart.
+
 ### Search Prefixes
 
 | Prefix | Provider | Example |
@@ -160,6 +281,7 @@ The `--prompt` flag sets a custom label for the search input.
 | `:calc` | Calculator | `:calc sqrt(16)` |
 | `:web` | Web search | `:web rust docs` |
 | `:uuctl` | systemd | `:uuctl docker` |
+| `:config` | Settings | `:config theme` |
 | `:tag:X` | Filter by tag | `:tag:development` |
 
 ### Trigger Prefixes
@@ -168,6 +290,7 @@ The `--prompt` flag sets a custom label for the search input.
 |---------|----------|---------|
 | `=` | Calculator | `= 5+3` |
 | `calc ` | Calculator | `calc sqrt(16)` |
+| `>` | Converter | `> 20 km to mi` |
 | `?` | Web search | `? rust programming` |
 | `web ` | Web search | `web linux tips` |
 | `/` | File search | `/ .bashrc` |
@@ -187,6 +310,7 @@ Owlry follows the [XDG Base Directory Specification](https://specifications.free
 | `~/.local/share/owlry/frecency.json` | Usage history |
 
 System locations:
+
 | Path | Purpose |
 |------|---------|
 | `/usr/lib/owlry/plugins/*.so` | Installed native plugins |
@@ -201,6 +325,8 @@ mkdir -p ~/.config/owlry
 cp /usr/share/doc/owlry/config.example.toml ~/.config/owlry/config.toml
 ```
 
+Or configure from within the launcher: type `:config` to interactively change settings.
+
 ### Example Configuration
 
 ```toml
@@ -208,8 +334,8 @@ cp /usr/share/doc/owlry/config.example.toml ~/.config/owlry/config.toml
 show_icons = true
 max_results = 10
 tabs = ["app", "cmd", "uuctl"]
-# terminal_command = "kitty"    # Auto-detected
-# launch_wrapper = "uwsm app --" # Auto-detected
+# terminal_command = "kitty"  # Auto-detected
+# use_uwsm = false            # Enable for systemd session integration
 
 [appearance]
 width = 850
@@ -224,18 +350,28 @@ disabled = []  # Plugin IDs to disable, e.g., ["emoji", "pomodoro"]
 [providers]
 applications = true    # .desktop files
 commands = true        # PATH executables
+calculator = true      # Built-in math expressions
+converter = true       # Built-in unit/currency conversion
+system = true          # Built-in shutdown/reboot/lock actions
 frecency = true        # Boost frequently used items
 frecency_weight = 0.3  # 0.0-1.0
 
 # Web search engine: google, duckduckgo, bing, startpage, brave, ecosia
 search_engine = "duckduckgo"
+
+# Profiles: named sets of modes
+[profiles.dev]
+modes = ["app", "cmd", "ssh"]
+
+[profiles.media]
+modes = ["media", "emoji"]
 ```
 
 See `/usr/share/doc/owlry/config.example.toml` for all options with documentation.
 
 ## Plugin System
 
-Owlry uses a modular plugin architecture. Plugins are loaded from:
+Owlry uses a modular plugin architecture. Plugins are loaded by the daemon from:
 
 - `/usr/lib/owlry/plugins/*.so` — System plugins (AUR packages)
 - `~/.config/owlry/plugins/` — User plugins (requires `owlry-lua` or `owlry-rune`)
@@ -249,6 +385,8 @@ Add plugin IDs to the disabled list in your config:
 disabled = ["emoji", "pomodoro"]
 ```
 
+Or toggle providers interactively: type `:config providers` in the launcher.
+
 ### Plugin Management CLI
 
 ```bash
@@ -304,12 +442,15 @@ See [docs/PLUGIN_DEVELOPMENT.md](docs/PLUGIN_DEVELOPMENT.md) for:
 | `tokyo-night` | Tokyo city lights |
 | `solarized-dark` | Precision colors |
 | `one-dark` | Atom's One Dark |
+| `apex-neon` | Neon cyberpunk |
 
 ```toml
 [appearance]
 theme = "catppuccin-mocha"
 ```
 
+Or select interactively: type `:config theme` in the launcher.
+
 ### Custom Theme
 
 Create `~/.config/owlry/themes/mytheme.css`:
@@ -337,21 +478,33 @@ Create `~/.config/owlry/themes/mytheme.css`:
 | `--owlry-text-secondary` | Muted text |
 | `--owlry-accent` | Accent color |
 | `--owlry-accent-bright` | Bright accent |
+| `--owlry-shadow` | Window shadow (default: none) |
 
 ## Architecture
 
+Owlry uses a client/daemon split:
+
 ```
-owlry (core)
-├── Applications provider (XDG .desktop files)
-├── Commands provider (PATH executables)
-├── Dmenu provider (pipe compatibility)
-└── Plugin loader
-    ├── /usr/lib/owlry/plugins/*.so  (native plugins)
-    ├── /usr/lib/owlry/runtimes/     (Lua/Rune runtimes)
-    └── ~/.config/owlry/plugins/     (user plugins)
+owlryd (daemon)                        owlry (GTK4 UI client)
+├── Loads config + plugins             ├── Connects to daemon via Unix socket
+├── Built-in providers                 ├── Renders results in GTK4 window
+│   ├── Applications (.desktop)        ├── Handles keyboard input
+│   ├── Commands (PATH)                ├── Toggle: second launch closes window
+│   ├── Calculator (math)              └── dmenu mode (self-contained, no daemon)
+│   ├── Converter (units/currency)
+│   ├── System (power/session)
+│   └── Config editor (settings)
+├── Plugin loader
+│   ├── /usr/lib/owlry/plugins/*.so
+│   ├── /usr/lib/owlry/runtimes/
+│   └── ~/.config/owlry/plugins/
+├── Frecency tracking
+└── IPC server (Unix socket)
+         │
+         └── $XDG_RUNTIME_DIR/owlry/owlry.sock
 ```
 
-For detailed architecture information, see [CLAUDE.md](CLAUDE.md).
+The daemon keeps providers and plugins loaded in memory, so the UI appears instantly when launched. The UI client is a thin GTK4 layer that sends queries and receives results over the socket.
 
 ## License
 

aur/owlry-core/.SRCINFO

@@ -0,0 +1,13 @@
+pkgbase = owlry-core
+	pkgdesc = Core daemon for the Owlry application launcher — manages plugins, providers, and search
+	pkgver = 1.3.1
+	pkgrel = 1
+	url = https://somegit.dev/Owlibou/owlry
+	arch = x86_64
+	license = GPL-3.0-or-later
+	makedepends = cargo
+	depends = gcc-libs
+	source = owlry-core-1.3.1.tar.gz::https://somegit.dev/Owlibou/owlry/archive/owlry-core-v1.3.1.tar.gz
+	b2sums = e37383fd650a3bf9a2c554eb37676037e3ae72bbc2e1aad7c316809094254173b6fcd5ac87907c2f38ce5506e9f26201ec62f82446bc789153c280373e31fc9e
+
+pkgname = owlry-core

aur/owlry-core/PKGBUILD

@@ -0,0 +1,41 @@
+# Maintainer: vikingowl <christian@nachtigall.dev>
+pkgname=owlry-core
+pkgver=1.3.1
+pkgrel=1
+pkgdesc='Core daemon for the Owlry application launcher — manages plugins, providers, and search'
+arch=('x86_64')
+url='https://somegit.dev/Owlibou/owlry'
+license=('GPL-3.0-or-later')
+depends=('gcc-libs')
+makedepends=('cargo')
+source=("$pkgname-$pkgver.tar.gz::https://somegit.dev/Owlibou/owlry/archive/owlry-core-v$pkgver.tar.gz")
+b2sums=('e37383fd650a3bf9a2c554eb37676037e3ae72bbc2e1aad7c316809094254173b6fcd5ac87907c2f38ce5506e9f26201ec62f82446bc789153c280373e31fc9e')
+
+prepare() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    cargo fetch --locked --target "$(rustc -vV | sed -n 's/host: //p')"
+}
+
+build() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    export CARGO_TARGET_DIR=target
+    cargo build -p owlry-core --frozen --release
+}
+
+check() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    export CARGO_TARGET_DIR=target
+    cargo test -p owlry-core --frozen --lib
+}
+
+package() {
+    cd "owlry"
+    install -Dm755 "target/release/owlryd" "$pkgdir/usr/bin/owlryd"
+    install -Dm644 "systemd/owlryd.service" "$pkgdir/usr/lib/systemd/user/owlryd.service"
+    install -Dm644 "systemd/owlryd.socket" "$pkgdir/usr/lib/systemd/user/owlryd.socket"
+    install -dm755 "$pkgdir/usr/lib/owlry/plugins"
+    install -dm755 "$pkgdir/usr/lib/owlry/runtimes"
+}

aur/owlry-lua/.SRCINFO

@@ -0,0 +1,13 @@
+pkgbase = owlry-lua
+	pkgdesc = Lua scripting runtime for Owlry — enables user-created Lua plugins
+	pkgver = 1.1.0
+	pkgrel = 1
+	url = https://somegit.dev/Owlibou/owlry
+	arch = x86_64
+	license = GPL-3.0-or-later
+	makedepends = cargo
+	depends = owlry-core
+	source = owlry-lua-1.1.0.tar.gz::https://somegit.dev/Owlibou/owlry/archive/owlry-lua-v1.1.0.tar.gz
+	b2sums = d4b200446a31301b1240fd8eede6e10764d7bbc551f2e5549bfdbdcc0fa4a717677c3c2c69778d2dfa336711ac5b74d4987e46082ea589fed961c9d2ff95af76
+
+pkgname = owlry-lua

aur/owlry-lua/PKGBUILD

@@ -0,0 +1,40 @@
+# Maintainer: vikingowl <christian@nachtigall.dev>
+pkgname=owlry-lua
+pkgver=1.1.0
+pkgrel=1
+pkgdesc="Lua scripting runtime for Owlry — enables user-created Lua plugins"
+arch=('x86_64')
+url="https://somegit.dev/Owlibou/owlry"
+license=('GPL-3.0-or-later')
+depends=('owlry-core')
+makedepends=('cargo')
+source=("$pkgname-$pkgver.tar.gz::https://somegit.dev/Owlibou/owlry/archive/owlry-lua-v$pkgver.tar.gz")
+b2sums=('d4b200446a31301b1240fd8eede6e10764d7bbc551f2e5549bfdbdcc0fa4a717677c3c2c69778d2dfa336711ac5b74d4987e46082ea589fed961c9d2ff95af76')
+
+_cratename=owlry-lua
+
+prepare() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    cargo fetch --locked --target "$(rustc -vV | sed -n 's/host: //p')"
+}
+
+build() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    export CARGO_TARGET_DIR=target
+    cargo build -p $_cratename --frozen --release
+}
+
+check() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    export CARGO_TARGET_DIR=target
+    cargo test -p $_cratename --frozen --release
+}
+
+package() {
+    cd "owlry"
+    install -Dm755 "target/release/lib${_cratename//-/_}.so" \
+        "$pkgdir/usr/lib/owlry/runtimes/liblua.so"
+}

aur/owlry-rune/.SRCINFO

@@ -0,0 +1,13 @@
+pkgbase = owlry-rune
+	pkgdesc = Rune scripting runtime for Owlry — enables user-created Rune plugins
+	pkgver = 1.1.0
+	pkgrel = 1
+	url = https://somegit.dev/Owlibou/owlry
+	arch = x86_64
+	license = GPL-3.0-or-later
+	makedepends = cargo
+	depends = owlry-core
+	source = owlry-rune-1.1.0.tar.gz::https://somegit.dev/Owlibou/owlry/archive/owlry-rune-v1.1.0.tar.gz
+	b2sums = d4b200446a31301b1240fd8eede6e10764d7bbc551f2e5549bfdbdcc0fa4a717677c3c2c69778d2dfa336711ac5b74d4987e46082ea589fed961c9d2ff95af76
+
+pkgname = owlry-rune

aur/owlry-rune/PKGBUILD

@@ -0,0 +1,40 @@
+# Maintainer: vikingowl <christian@nachtigall.dev>
+pkgname=owlry-rune
+pkgver=1.1.0
+pkgrel=1
+pkgdesc="Rune scripting runtime for Owlry — enables user-created Rune plugins"
+arch=('x86_64')
+url="https://somegit.dev/Owlibou/owlry"
+license=('GPL-3.0-or-later')
+depends=('owlry-core')
+makedepends=('cargo')
+source=("$pkgname-$pkgver.tar.gz::https://somegit.dev/Owlibou/owlry/archive/owlry-rune-v$pkgver.tar.gz")
+b2sums=('d4b200446a31301b1240fd8eede6e10764d7bbc551f2e5549bfdbdcc0fa4a717677c3c2c69778d2dfa336711ac5b74d4987e46082ea589fed961c9d2ff95af76')
+
+_cratename=owlry-rune
+
+prepare() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    cargo fetch --locked --target "$(rustc -vV | sed -n 's/host: //p')"
+}
+
+build() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    export CARGO_TARGET_DIR=target
+    cargo build -p $_cratename --frozen --release
+}
+
+check() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    export CARGO_TARGET_DIR=target
+    cargo test -p $_cratename --frozen --release
+}
+
+package() {
+    cd "owlry"
+    install -Dm755 "target/release/lib${_cratename//-/_}.so" \
+        "$pkgdir/usr/lib/owlry/runtimes/librune.so"
+}

aur/owlry/.SRCINFO

@@ -0,0 +1,34 @@
+pkgbase = owlry
+	pkgdesc = Lightweight Wayland application launcher with plugin support
+	pkgver = 1.0.6
+	pkgrel = 1
+	url = https://somegit.dev/Owlibou/owlry
+	arch = x86_64
+	license = GPL-3.0-or-later
+	makedepends = cargo
+	depends = owlry-core
+	depends = gcc-libs
+	depends = gtk4
+	depends = gtk4-layer-shell
+	optdepends = cliphist: clipboard provider support
+	optdepends = wl-clipboard: clipboard and emoji copy support
+	optdepends = fd: fast file search
+	optdepends = owlry-plugin-calculator: calculator provider
+	optdepends = owlry-plugin-clipboard: clipboard provider
+	optdepends = owlry-plugin-emoji: emoji picker
+	optdepends = owlry-plugin-bookmarks: browser bookmarks
+	optdepends = owlry-plugin-ssh: SSH host launcher
+	optdepends = owlry-plugin-scripts: custom scripts provider
+	optdepends = owlry-plugin-system: system actions (shutdown, reboot, etc.)
+	optdepends = owlry-plugin-websearch: web search provider
+	optdepends = owlry-plugin-filesearch: file search provider
+	optdepends = owlry-plugin-systemd: systemd service management
+	optdepends = owlry-plugin-weather: weather widget
+	optdepends = owlry-plugin-media: media player controls
+	optdepends = owlry-plugin-pomodoro: pomodoro timer widget
+	optdepends = owlry-lua: Lua runtime for user plugins
+	optdepends = owlry-rune: Rune runtime for user plugins
+	source = owlry-1.0.6.tar.gz::https://somegit.dev/Owlibou/owlry/archive/owlry-v1.0.6.tar.gz
+	b2sums = 8967562bda33820b282350eaad17e8194699926b721eabe978fb0b70af2a75e399866c6bfa7abb449141701bad618df56079c7e81358708b1852b1070b0b7c05
+
+pkgname = owlry

aur/owlry/PKGBUILD

@@ -0,0 +1,76 @@
+# Maintainer: vikingowl <christian@nachtigall.dev>
+pkgname=owlry
+pkgver=1.0.6
+pkgrel=1
+pkgdesc="Lightweight Wayland application launcher with plugin support"
+arch=('x86_64')
+url="https://somegit.dev/Owlibou/owlry"
+license=('GPL-3.0-or-later')
+depends=('owlry-core' 'gcc-libs' 'gtk4' 'gtk4-layer-shell')
+makedepends=('cargo')
+optdepends=(
+    'cliphist: clipboard provider support'
+    'wl-clipboard: clipboard and emoji copy support'
+    'fd: fast file search'
+    'owlry-plugin-calculator: calculator provider'
+    'owlry-plugin-clipboard: clipboard provider'
+    'owlry-plugin-emoji: emoji picker'
+    'owlry-plugin-bookmarks: browser bookmarks'
+    'owlry-plugin-ssh: SSH host launcher'
+    'owlry-plugin-scripts: custom scripts provider'
+    'owlry-plugin-system: system actions (shutdown, reboot, etc.)'
+    'owlry-plugin-websearch: web search provider'
+    'owlry-plugin-filesearch: file search provider'
+    'owlry-plugin-systemd: systemd service management'
+    'owlry-plugin-weather: weather widget'
+    'owlry-plugin-media: media player controls'
+    'owlry-plugin-pomodoro: pomodoro timer widget'
+    'owlry-lua: Lua runtime for user plugins'
+    'owlry-rune: Rune runtime for user plugins'
+)
+source=("$pkgname-$pkgver.tar.gz::https://somegit.dev/Owlibou/owlry/archive/owlry-v$pkgver.tar.gz")
+b2sums=('8967562bda33820b282350eaad17e8194699926b721eabe978fb0b70af2a75e399866c6bfa7abb449141701bad618df56079c7e81358708b1852b1070b0b7c05')
+
+prepare() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    cargo fetch --locked --target "$(rustc -vV | sed -n 's/host: //p')"
+}
+
+build() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    export CARGO_TARGET_DIR=target
+    # Build only the core binary without embedded Lua (Lua runtime is separate package)
+    cargo build -p owlry --frozen --release --no-default-features
+}
+
+check() {
+    cd "owlry"
+    export RUSTUP_TOOLCHAIN=stable
+    export CARGO_TARGET_DIR=target
+    cargo test -p owlry --frozen --no-default-features
+}
+
+package() {
+    cd "owlry"
+
+    # Core binary
+    install -Dm755 "target/release/$pkgname" "$pkgdir/usr/bin/$pkgname"
+
+    # Documentation
+    install -Dm644 README.md "$pkgdir/usr/share/doc/$pkgname/README.md"
+
+    # Example configuration files
+    install -Dm644 data/config.example.toml "$pkgdir/usr/share/doc/$pkgname/config.example.toml"
+    install -Dm644 data/style.example.css "$pkgdir/usr/share/doc/$pkgname/style.example.css"
+    install -Dm755 data/scripts/example.sh "$pkgdir/usr/share/doc/$pkgname/scripts/example.sh"
+
+    # Install themes
+    install -d "$pkgdir/usr/share/$pkgname/themes"
+    install -Dm644 data/themes/*.css "$pkgdir/usr/share/$pkgname/themes/"
+
+    # Example plugins (for user plugin development)
+    install -d "$pkgdir/usr/share/$pkgname/examples/plugins"
+    cp -r examples/plugins/* "$pkgdir/usr/share/$pkgname/examples/plugins/"
+}

crates/owlry-core/Cargo.toml

@@ -0,0 +1,64 @@
+[package]
+name = "owlry-core"
+version = "1.3.1"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+description = "Core daemon for the Owlry application launcher"
+
+[lib]
+name = "owlry_core"
+path = "src/lib.rs"
+
+[[bin]]
+name = "owlryd"
+path = "src/main.rs"
+
+[dependencies]
+owlry-plugin-api = { path = "../owlry-plugin-api" }
+
+# Provider system
+fuzzy-matcher = "0.3"
+freedesktop-desktop-entry = "0.8"
+
+# Plugin loading
+libloading = "0.8"
+semver = "1"
+
+# Data & config
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+toml = "0.8"
+chrono = { version = "0.4", features = ["serde"] }
+dirs = "5"
+
+# Error handling
+thiserror = "2"
+
+# Filesystem watching (plugin hot-reload)
+notify = "7"
+notify-debouncer-mini = "0.5"
+
+# Signal handling
+ctrlc = { version = "3", features = ["termination"] }
+
+# Logging & notifications
+log = "0.4"
+env_logger = "0.11"
+notify-rust = "4"
+
+# Built-in providers
+meval = "0.2"
+reqwest = { version = "0.13", default-features = false, features = ["rustls", "json", "blocking"] }
+
+# Optional: embedded Lua runtime
+mlua = { version = "0.11", features = ["lua54", "vendored", "send", "serialize"], optional = true }
+
+[dev-dependencies]
+tempfile = "3"
+
+[features]
+default = []
+lua = ["dep:mlua"]
+dev-logging = []

crates/owlry-core/src/config/mod.rs

@@ -2,10 +2,24 @@ use log::{debug, info, warn};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::PathBuf;
-use std::process::Command;
 
 use crate::paths;
 
+/// A named profile that selects a set of provider modes.
+///
+/// Defined in config.toml as:
+/// ```toml
+/// [profiles.dev]
+/// modes = ["app", "cmd", "ssh"]
+///
+/// [profiles.media]
+/// modes = ["media", "emoji"]
+/// ```
+#[derive(Debug, Clone, Default, Deserialize, Serialize)]
+pub struct ProfileConfig {
+    pub modes: Vec<String>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct Config {
     #[serde(default)]
@@ -16,6 +30,8 @@ pub struct Config {
     pub providers: ProvidersConfig,
     #[serde(default)]
     pub plugins: PluginsConfig,
+    #[serde(default)]
+    pub profiles: HashMap<String, ProfileConfig>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -27,11 +43,12 @@ pub struct GeneralConfig {
     /// Terminal command (auto-detected if not specified)
     #[serde(default)]
     pub terminal_command: Option<String>,
-    /// Launch wrapper command for app execution.
-    /// Examples: "uwsm app --", "hyprctl dispatch exec --", "systemd-run --user --"
-    /// If None or empty, launches directly via sh -c
+    /// Enable uwsm (Universal Wayland Session Manager) for launching apps.
+    /// When enabled, desktop files are launched via `uwsm app -- <file>`
+    /// which starts apps in a proper systemd user session.
+    /// When disabled (default), apps are launched via `gio launch`.
     #[serde(default)]
-    pub launch_wrapper: Option<String>,
+    pub use_uwsm: bool,
     /// Provider tabs shown in the header bar.
     /// Valid values: app, cmd, uuctl, bookmark, calc, clip, dmenu, emoji, file, script, ssh, sys, web
     #[serde(default = "default_tabs")]
@@ -44,7 +61,7 @@ impl Default for GeneralConfig {
             show_icons: true,
             max_results: 100,
             terminal_command: None,
-            launch_wrapper: None,
+            use_uwsm: false,
             tabs: default_tabs(),
         }
     }
@@ -55,11 +72,7 @@ fn default_max_results() -> usize {
 }
 
 fn default_tabs() -> Vec<String> {
-    vec![
-        "app".to_string(),
-        "cmd".to_string(),
-        "uuctl".to_string(),
-    ]
+    vec!["app".to_string(), "cmd".to_string(), "uuctl".to_string()]
 }
 
 /// User-customizable theme colors
@@ -125,10 +138,18 @@ impl Default for AppearanceConfig {
     }
 }
 
-fn default_width() -> i32 { 850 }
-fn default_height() -> i32 { 650 }
-fn default_font_size() -> u32 { 14 }
-fn default_border_radius() -> u32 { 12 }
+fn default_width() -> i32 {
+    850
+}
+fn default_height() -> i32 {
+    650
+}
+fn default_font_size() -> u32 {
+    14
+}
+fn default_border_radius() -> u32 {
+    12
+}
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ProvidersConfig {
@@ -141,6 +162,9 @@ pub struct ProvidersConfig {
     /// Enable calculator provider (= expression or calc expression)
     #[serde(default = "default_true")]
     pub calculator: bool,
+    /// Enable converter provider (> expression or auto-detect)
+    #[serde(default = "default_true")]
+    pub converter: bool,
     /// Enable frecency-based result ranking
     #[serde(default = "default_true")]
     pub frecency: bool,
@@ -178,7 +202,6 @@ pub struct ProvidersConfig {
     pub files: bool,
 
     // ─── Widget Providers ───────────────────────────────────────────────
-
     /// Enable MPRIS media player widget
     #[serde(default = "default_true")]
     pub media: bool,
@@ -219,6 +242,7 @@ impl Default for ProvidersConfig {
             commands: true,
             uuctl: true,
             calculator: true,
+            converter: true,
             frecency: true,
             frecency_weight: 0.3,
             websearch: true,
@@ -332,28 +356,19 @@ impl PluginsConfig {
     /// Get a string value from a plugin's config
     #[allow(dead_code)]
     pub fn get_plugin_string(&self, plugin_name: &str, key: &str) -> Option<&str> {
-        self.plugin_configs
-            .get(plugin_name)?
-            .get(key)?
-            .as_str()
+        self.plugin_configs.get(plugin_name)?.get(key)?.as_str()
     }
 
     /// Get an integer value from a plugin's config
     #[allow(dead_code)]
     pub fn get_plugin_int(&self, plugin_name: &str, key: &str) -> Option<i64> {
-        self.plugin_configs
-            .get(plugin_name)?
-            .get(key)?
-            .as_integer()
+        self.plugin_configs.get(plugin_name)?.get(key)?.as_integer()
     }
 
     /// Get a boolean value from a plugin's config
     #[allow(dead_code)]
     pub fn get_plugin_bool(&self, plugin_name: &str, key: &str) -> Option<bool> {
-        self.plugin_configs
-            .get(plugin_name)?
-            .get(key)?
-            .as_bool()
+        self.plugin_configs.get(plugin_name)?.get(key)?.as_bool()
     }
 }
 
@@ -396,29 +411,6 @@ fn default_pomodoro_break() -> u32 {
     5
 }
 
-/// Detect the best launch wrapper for the current session
-/// Checks for uwsm (Universal Wayland Session Manager) and hyprland
-fn detect_launch_wrapper() -> Option<String> {
-    // Check if running under uwsm (has UWSM_FINALIZE_VARNAMES or similar uwsm env vars)
-    if (std::env::var("UWSM_FINALIZE_VARNAMES").is_ok()
-        || std::env::var("__UWSM_SELECT_TAG").is_ok())
-        && command_exists("uwsm") {
-            debug!("Detected uwsm session, using 'uwsm app --' wrapper");
-            return Some("uwsm app --".to_string());
-        }
-
-    // Check if running under Hyprland
-    if std::env::var("HYPRLAND_INSTANCE_SIGNATURE").is_ok()
-        && command_exists("hyprctl") {
-            debug!("Detected Hyprland session, using 'hyprctl dispatch exec --' wrapper");
-            return Some("hyprctl dispatch exec --".to_string());
-        }
-
-    // No wrapper needed for other environments
-    debug!("No launch wrapper detected, using direct execution");
-    None
-}
-
 /// Detect the best available terminal emulator
 /// Fallback chain:
 /// 1. $TERMINAL env var (user's explicit preference)
@@ -431,10 +423,12 @@ fn detect_launch_wrapper() -> Option<String> {
 fn detect_terminal() -> String {
     // 1. Check $TERMINAL env var first (user's explicit preference)
     if let Ok(term) = std::env::var("TERMINAL")
-        && !term.is_empty() && command_exists(&term) {
-            debug!("Using $TERMINAL: {}", term);
-            return term;
-        }
+        && !term.is_empty()
+        && command_exists(&term)
+    {
+        debug!("Using $TERMINAL: {}", term);
+        return term;
+    }
 
     // 2. Try xdg-terminal-exec (freedesktop standard)
     if command_exists("xdg-terminal-exec") {
@@ -458,7 +452,14 @@ fn detect_terminal() -> String {
     }
 
     // 5. Common X11/legacy terminals
-    let legacy_terminals = ["gnome-terminal", "konsole", "xfce4-terminal", "mate-terminal", "tilix", "terminator"];
+    let legacy_terminals = [
+        "gnome-terminal",
+        "konsole",
+        "xfce4-terminal",
+        "mate-terminal",
+        "tilix",
+        "terminator",
+    ];
     for term in legacy_terminals {
         if command_exists(term) {
             debug!("Found legacy terminal: {}", term);
@@ -524,12 +525,15 @@ fn detect_de_terminal() -> Option<String> {
     None
 }
 
-/// Check if a command exists in PATH
+/// Check if a command exists in PATH (in-process, no subprocess spawning)
 fn command_exists(cmd: &str) -> bool {
-    Command::new("which")
-        .arg(cmd)
-        .output()
-        .map(|o| o.status.success())
+    std::env::var_os("PATH")
+        .map(|paths| {
+            std::env::split_paths(&paths).any(|dir| {
+                let full = dir.join(cmd);
+                full.is_file()
+            })
+        })
         .unwrap_or(false)
 }
 
@@ -578,11 +582,6 @@ impl Config {
             }
         }
 
-        // Auto-detect launch wrapper if not configured
-        if config.general.launch_wrapper.is_none() {
-            config.general.launch_wrapper = detect_launch_wrapper();
-        }
-
         Ok(config)
     }
 
@@ -598,3 +597,17 @@ impl Config {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn command_exists_finds_sh() {
+        // /bin/sh exists on every Unix system
+        assert!(super::command_exists("sh"));
+    }
+
+    #[test]
+    fn command_exists_rejects_nonexistent() {
+        assert!(!super::command_exists("owlry_nonexistent_binary_abc123"));
+    }
+}

crates/owlry-core/src/data/frecency.rs

@@ -131,23 +131,36 @@ impl FrecencyStore {
         }
     }
 
+    /// Calculate frecency score using a pre-sampled timestamp.
+    /// Use this in hot loops to avoid repeated Utc::now() syscalls.
+    pub fn get_score_at(&self, item_id: &str, now: DateTime<Utc>) -> f64 {
+        match self.data.entries.get(item_id) {
+            Some(entry) => Self::calculate_frecency_at(entry.launch_count, entry.last_launch, now),
+            None => 0.0,
+        }
+    }
+
     /// Calculate frecency using Firefox-style algorithm
     fn calculate_frecency(launch_count: u32, last_launch: DateTime<Utc>) -> f64 {
         let now = Utc::now();
+        Self::calculate_frecency_at(launch_count, last_launch, now)
+    }
+
+    /// Calculate frecency using a caller-provided timestamp.
+    fn calculate_frecency_at(launch_count: u32, last_launch: DateTime<Utc>, now: DateTime<Utc>) -> f64 {
         let age = now.signed_duration_since(last_launch);
         let age_days = age.num_hours() as f64 / 24.0;
 
-        // Recency weight based on how recently the item was used
         let recency_weight = if age_days < 1.0 {
-            100.0 // Today
+            100.0
         } else if age_days < 7.0 {
-            70.0 // This week
+            70.0
         } else if age_days < 30.0 {
-            50.0 // This month
+            50.0
         } else if age_days < 90.0 {
-            30.0 // This quarter
+            30.0
         } else {
-            10.0 // Older
+            10.0
         };
 
         launch_count as f64 * recency_weight
@@ -206,6 +219,32 @@ mod tests {
         assert!(score_month < score_week);
     }
 
+    #[test]
+    fn get_score_at_matches_get_score() {
+        let mut store = FrecencyStore {
+            data: FrecencyData {
+                version: 1,
+                entries: HashMap::new(),
+            },
+            path: PathBuf::from("/dev/null"),
+            dirty: false,
+        };
+        store.data.entries.insert(
+            "test".to_string(),
+            FrecencyEntry {
+                launch_count: 5,
+                last_launch: Utc::now(),
+            },
+        );
+
+        let now = Utc::now();
+        let score_at = store.get_score_at("test", now);
+        let score = store.get_score("test");
+
+        // Both should be very close (same timestamp, within rounding)
+        assert!((score_at - score).abs() < 1.0);
+    }
+
     #[test]
     fn test_launch_count_matters() {
         let now = Utc::now();

crates/owlry-core/src/filter.rs

@@ -11,6 +11,10 @@ use crate::providers::ProviderType;
 pub struct ProviderFilter {
     enabled: HashSet<ProviderType>,
     active_prefix: Option<ProviderType>,
+    /// When true, `is_active`/`is_enabled` accept any provider type
+    /// (unless a prefix narrows the scope). Used by `all()` so that
+    /// dynamically loaded plugins are accepted without being listed.
+    accept_all: bool,
 }
 
 /// Result of parsing a query for prefix syntax
@@ -28,6 +32,8 @@ impl ProviderFilter {
         cli_providers: Option<Vec<ProviderType>>,
         config_providers: &ProvidersConfig,
     ) -> Self {
+        let accept_all = cli_mode.is_none() && cli_providers.is_none();
+
         let enabled = if let Some(mode) = cli_mode {
             // --mode overrides everything: single provider
             HashSet::from([mode])
@@ -86,10 +92,14 @@ impl ProviderFilter {
         let filter = Self {
             enabled,
             active_prefix: None,
+            accept_all,
         };
 
         #[cfg(feature = "dev-logging")]
-        debug!("[Filter] Created with enabled providers: {:?}", filter.enabled);
+        debug!(
+            "[Filter] Created with enabled providers: {:?}",
+            filter.enabled
+        );
 
         filter
     }
@@ -100,6 +110,7 @@ impl ProviderFilter {
         Self {
             enabled: HashSet::from([ProviderType::Application]),
             active_prefix: None,
+            accept_all: false,
         }
     }
 
@@ -112,13 +123,19 @@ impl ProviderFilter {
                 self.enabled.insert(ProviderType::Application);
             }
             #[cfg(feature = "dev-logging")]
-            debug!("[Filter] Toggled OFF {:?}, enabled: {:?}", provider, self.enabled);
+            debug!(
+                "[Filter] Toggled OFF {:?}, enabled: {:?}",
+                provider, self.enabled
+            );
         } else {
             #[cfg(feature = "dev-logging")]
             let provider_debug = format!("{:?}", provider);
             self.enabled.insert(provider);
             #[cfg(feature = "dev-logging")]
-            debug!("[Filter] Toggled ON {}, enabled: {:?}", provider_debug, self.enabled);
+            debug!(
+                "[Filter] Toggled ON {}, enabled: {:?}",
+                provider_debug, self.enabled
+            );
         }
     }
 
@@ -145,7 +162,10 @@ impl ProviderFilter {
     pub fn set_prefix(&mut self, prefix: Option<ProviderType>) {
         #[cfg(feature = "dev-logging")]
         if self.active_prefix != prefix {
-            debug!("[Filter] Prefix changed: {:?} -> {:?}", self.active_prefix, prefix);
+            debug!(
+                "[Filter] Prefix changed: {:?} -> {:?}",
+                self.active_prefix, prefix
+            );
         }
         self.active_prefix = prefix;
     }
@@ -154,6 +174,8 @@ impl ProviderFilter {
     pub fn is_active(&self, provider: ProviderType) -> bool {
         if let Some(ref prefix) = self.active_prefix {
             &provider == prefix
+        } else if self.accept_all {
+            true
         } else {
             self.enabled.contains(&provider)
         }
@@ -161,7 +183,12 @@ impl ProviderFilter {
 
     /// Check if provider is in enabled set (ignoring prefix)
     pub fn is_enabled(&self, provider: ProviderType) -> bool {
-        self.enabled.contains(&provider)
+        self.accept_all || self.enabled.contains(&provider)
+    }
+
+    /// Whether this filter accepts all provider types
+    pub fn is_accept_all(&self) -> bool {
+        self.accept_all
     }
 
     /// Get current active prefix if any
@@ -182,7 +209,10 @@ impl ProviderFilter {
                 let tag = rest[..space_idx].to_lowercase();
                 let query_part = rest[space_idx + 1..].to_string();
                 #[cfg(feature = "dev-logging")]
-                debug!("[Filter] parse_query({:?}) -> tag={:?}, query={:?}", query, tag, query_part);
+                debug!(
+                    "[Filter] parse_query({:?}) -> tag={:?}, query={:?}",
+                    query, tag, query_part
+                );
                 return ParsedQuery {
                     prefix: None,
                     tag_filter: Some(tag),
@@ -231,13 +261,20 @@ impl ProviderFilter {
             (":systemd ", "uuctl"),
             (":web ", "websearch"),
             (":search ", "websearch"),
+            (":config ", "config"),
+            (":settings ", "config"),
+            (":conv ", "conv"),
+            (":converter ", "conv"),
         ];
 
         // Check core prefixes
         for (prefix_str, provider) in core_prefixes {
             if let Some(rest) = trimmed.strip_prefix(prefix_str) {
                 #[cfg(feature = "dev-logging")]
-                debug!("[Filter] parse_query({:?}) -> prefix={:?}, query={:?}", query, provider, rest);
+                debug!(
+                    "[Filter] parse_query({:?}) -> prefix={:?}, query={:?}",
+                    query, provider, rest
+                );
                 return ParsedQuery {
                     prefix: Some(provider.clone()),
                     tag_filter: None,
@@ -251,7 +288,10 @@ impl ProviderFilter {
             if let Some(rest) = trimmed.strip_prefix(prefix_str) {
                 let provider = ProviderType::Plugin(type_id.to_string());
                 #[cfg(feature = "dev-logging")]
-                debug!("[Filter] parse_query({:?}) -> prefix={:?}, query={:?}", query, provider, rest);
+                debug!(
+                    "[Filter] parse_query({:?}) -> prefix={:?}, query={:?}",
+                    query, provider, rest
+                );
                 return ParsedQuery {
                     prefix: Some(provider),
                     tag_filter: None,
@@ -291,12 +331,19 @@ impl ProviderFilter {
             (":systemd", "uuctl"),
             (":web", "websearch"),
             (":search", "websearch"),
+            (":config", "config"),
+            (":settings", "config"),
+            (":conv", "conv"),
+            (":converter", "conv"),
         ];
 
         for (prefix_str, provider) in partial_core {
             if trimmed == *prefix_str {
                 #[cfg(feature = "dev-logging")]
-                debug!("[Filter] parse_query({:?}) -> partial prefix {:?}", query, provider);
+                debug!(
+                    "[Filter] parse_query({:?}) -> partial prefix {:?}",
+                    query, provider
+                );
                 return ParsedQuery {
                     prefix: Some(provider.clone()),
                     tag_filter: None,
@@ -309,7 +356,10 @@ impl ProviderFilter {
             if trimmed == *prefix_str {
                 let provider = ProviderType::Plugin(type_id.to_string());
                 #[cfg(feature = "dev-logging")]
-                debug!("[Filter] parse_query({:?}) -> partial prefix {:?}", query, provider);
+                debug!(
+                    "[Filter] parse_query({:?}) -> partial prefix {:?}",
+                    query, provider
+                );
                 return ParsedQuery {
                     prefix: Some(provider),
                     tag_filter: None,
@@ -318,6 +368,28 @@ impl ProviderFilter {
             }
         }
 
+        // Dynamic plugin prefix fallback: ":word " or ":word" where word is unknown
+        // Maps to Plugin(word) so user plugins with custom prefixes work
+        if let Some(rest) = trimmed.strip_prefix(':') {
+            if let Some(space_idx) = rest.find(' ') {
+                let prefix_word = &rest[..space_idx];
+                if !prefix_word.is_empty() && prefix_word.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
+                    return ParsedQuery {
+                        prefix: Some(ProviderType::Plugin(prefix_word.to_string())),
+                        tag_filter: None,
+                        query: rest[space_idx + 1..].to_string(),
+                    };
+                }
+            } else if !rest.is_empty() && rest.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
+                // Partial prefix (no space yet)
+                return ParsedQuery {
+                    prefix: Some(ProviderType::Plugin(rest.to_string())),
+                    tag_filter: None,
+                    query: String::new(),
+                };
+            }
+        }
+
         let result = ParsedQuery {
             prefix: None,
             tag_filter: None,
@@ -325,7 +397,10 @@ impl ProviderFilter {
         };
 
         #[cfg(feature = "dev-logging")]
-        debug!("[Filter] parse_query({:?}) -> prefix={:?}, tag={:?}, query={:?}", query, result.prefix, result.tag_filter, result.query);
+        debug!(
+            "[Filter] parse_query({:?}) -> prefix={:?}, tag={:?}, query={:?}",
+            query, result.prefix, result.tag_filter, result.query
+        );
 
         result
     }
@@ -342,6 +417,56 @@ impl ProviderFilter {
         providers
     }
 
+    /// Create a filter from a list of mode name strings.
+    ///
+    /// Maps each string to a ProviderType: "app" -> Application, "cmd" -> Command,
+    /// "dmenu" -> Dmenu, anything else -> Plugin(id). An empty list produces an
+    /// all-providers filter.
+    pub fn from_mode_strings(modes: &[String]) -> Self {
+        if modes.is_empty() {
+            return Self::all();
+        }
+        let enabled: HashSet<ProviderType> = modes
+            .iter()
+            .map(|s| Self::mode_string_to_provider_type(s))
+            .collect();
+        Self {
+            enabled,
+            active_prefix: None,
+            accept_all: false,
+        }
+    }
+
+    /// Create a filter that accepts all providers, including any
+    /// dynamically loaded plugin.
+    ///
+    /// Sets `accept_all` so that `is_active`/`is_enabled` return true for
+    /// every `ProviderType` without maintaining a static list of plugin IDs.
+    /// Core types are still placed in `enabled` for UI purposes (tab display).
+    ///
+    /// The daemon uses this as the default when no modes are specified.
+    pub fn all() -> Self {
+        let mut enabled = HashSet::new();
+        enabled.insert(ProviderType::Application);
+        enabled.insert(ProviderType::Command);
+        enabled.insert(ProviderType::Dmenu);
+        Self {
+            enabled,
+            active_prefix: None,
+            accept_all: true,
+        }
+    }
+
+    /// Map a mode string to a ProviderType.
+    ///
+    /// Delegates to the existing `FromStr` impl on `ProviderType` which maps
+    /// "app"/"apps"/"application" -> Application, "cmd"/"command" -> Command,
+    /// "dmenu" -> Dmenu, and everything else -> Plugin(id).
+    pub fn mode_string_to_provider_type(mode: &str) -> ProviderType {
+        mode.parse::<ProviderType>()
+            .unwrap_or_else(|_| ProviderType::Plugin(mode.to_string()))
+    }
+
     /// Get display name for current mode
     pub fn mode_display_name(&self) -> &'static str {
         if let Some(ref prefix) = self.active_prefix {
@@ -395,7 +520,10 @@ mod tests {
     #[test]
     fn test_parse_query_plugin_prefix() {
         let result = ProviderFilter::parse_query(":calc 5+3");
-        assert_eq!(result.prefix, Some(ProviderType::Plugin("calc".to_string())));
+        assert_eq!(
+            result.prefix,
+            Some(ProviderType::Plugin("calc".to_string()))
+        );
         assert_eq!(result.query, "5+3");
     }
 
@@ -406,4 +534,136 @@ mod tests {
         // Should still have apps enabled as fallback
         assert!(filter.is_enabled(ProviderType::Application));
     }
+
+    #[test]
+    fn test_from_mode_strings_single_core() {
+        let filter = ProviderFilter::from_mode_strings(&["app".to_string()]);
+        assert!(filter.is_enabled(ProviderType::Application));
+        assert!(!filter.is_enabled(ProviderType::Command));
+    }
+
+    #[test]
+    fn test_from_mode_strings_multiple() {
+        let filter = ProviderFilter::from_mode_strings(&[
+            "app".to_string(),
+            "cmd".to_string(),
+            "calc".to_string(),
+        ]);
+        assert!(filter.is_enabled(ProviderType::Application));
+        assert!(filter.is_enabled(ProviderType::Command));
+        assert!(filter.is_enabled(ProviderType::Plugin("calc".to_string())));
+        assert!(!filter.is_enabled(ProviderType::Dmenu));
+    }
+
+    #[test]
+    fn test_from_mode_strings_empty_returns_all() {
+        let filter = ProviderFilter::from_mode_strings(&[]);
+        assert!(filter.is_enabled(ProviderType::Application));
+        assert!(filter.is_enabled(ProviderType::Command));
+        assert!(filter.is_enabled(ProviderType::Dmenu));
+    }
+
+    #[test]
+    fn test_from_mode_strings_plugin() {
+        let filter = ProviderFilter::from_mode_strings(&["emoji".to_string()]);
+        assert!(filter.is_enabled(ProviderType::Plugin("emoji".to_string())));
+        assert!(!filter.is_enabled(ProviderType::Application));
+    }
+
+    #[test]
+    fn test_from_mode_strings_dmenu() {
+        let filter = ProviderFilter::from_mode_strings(&["dmenu".to_string()]);
+        assert!(filter.is_enabled(ProviderType::Dmenu));
+        assert!(!filter.is_enabled(ProviderType::Application));
+    }
+
+    #[test]
+    fn test_all_includes_core_types() {
+        let filter = ProviderFilter::all();
+        assert!(filter.is_enabled(ProviderType::Application));
+        assert!(filter.is_enabled(ProviderType::Command));
+        assert!(filter.is_enabled(ProviderType::Dmenu));
+    }
+
+    #[test]
+    fn test_all_accepts_any_plugin() {
+        let filter = ProviderFilter::all();
+        // Known plugins
+        assert!(filter.is_enabled(ProviderType::Plugin("calc".to_string())));
+        assert!(filter.is_enabled(ProviderType::Plugin("clipboard".to_string())));
+        // Arbitrary unknown plugins must also be accepted
+        assert!(filter.is_enabled(ProviderType::Plugin("some-future-plugin".to_string())));
+        assert!(filter.is_enabled(ProviderType::Plugin("custom-user-plugin".to_string())));
+    }
+
+    #[test]
+    fn test_all_is_active_for_any_plugin() {
+        let filter = ProviderFilter::all();
+        assert!(filter.is_active(ProviderType::Application));
+        assert!(filter.is_active(ProviderType::Plugin("unknown-plugin".to_string())));
+    }
+
+    #[test]
+    fn test_all_with_prefix_narrows_scope() {
+        let mut filter = ProviderFilter::all();
+        filter.set_prefix(Some(ProviderType::Application));
+        // Prefix narrows: only Application passes
+        assert!(filter.is_active(ProviderType::Application));
+        assert!(!filter.is_active(ProviderType::Command));
+        assert!(!filter.is_active(ProviderType::Plugin("calc".to_string())));
+    }
+
+    #[test]
+    fn test_explicit_mode_filter_rejects_unknown_plugins() {
+        let filter = ProviderFilter::from_mode_strings(&["app".to_string(), "cmd".to_string()]);
+        assert!(filter.is_active(ProviderType::Application));
+        assert!(filter.is_active(ProviderType::Command));
+        // Plugins not in the explicit list must be rejected
+        assert!(!filter.is_active(ProviderType::Plugin("calc".to_string())));
+        assert!(!filter.is_active(ProviderType::Plugin("unknown".to_string())));
+    }
+
+    #[test]
+    fn test_mode_string_to_provider_type_core() {
+        assert_eq!(
+            ProviderFilter::mode_string_to_provider_type("app"),
+            ProviderType::Application
+        );
+        assert_eq!(
+            ProviderFilter::mode_string_to_provider_type("cmd"),
+            ProviderType::Command
+        );
+        assert_eq!(
+            ProviderFilter::mode_string_to_provider_type("dmenu"),
+            ProviderType::Dmenu
+        );
+    }
+
+    #[test]
+    fn test_mode_string_to_provider_type_plugin() {
+        assert_eq!(
+            ProviderFilter::mode_string_to_provider_type("calc"),
+            ProviderType::Plugin("calc".to_string())
+        );
+        assert_eq!(
+            ProviderFilter::mode_string_to_provider_type("websearch"),
+            ProviderType::Plugin("websearch".to_string())
+        );
+    }
+
+    #[test]
+    fn test_mode_string_to_provider_type_aliases() {
+        assert_eq!(
+            ProviderFilter::mode_string_to_provider_type("apps"),
+            ProviderType::Application
+        );
+        assert_eq!(
+            ProviderFilter::mode_string_to_provider_type("application"),
+            ProviderType::Application
+        );
+        assert_eq!(
+            ProviderFilter::mode_string_to_provider_type("command"),
+            ProviderType::Command
+        );
+    }
 }

crates/owlry-core/src/ipc.rs

@@ -0,0 +1,63 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum Request {
+    Query {
+        text: String,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        modes: Option<Vec<String>>,
+    },
+    Launch {
+        item_id: String,
+        provider: String,
+    },
+    Providers,
+    Refresh {
+        provider: String,
+    },
+    Toggle,
+    Submenu {
+        plugin_id: String,
+        data: String,
+    },
+    PluginAction {
+        command: String,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum Response {
+    Results { items: Vec<ResultItem> },
+    Providers { list: Vec<ProviderDesc> },
+    SubmenuItems { items: Vec<ResultItem> },
+    Ack,
+    Error { message: String },
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ResultItem {
+    pub id: String,
+    pub title: String,
+    pub description: String,
+    pub icon: String,
+    pub provider: String,
+    pub score: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub command: Option<String>,
+    #[serde(default)]
+    pub terminal: bool,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ProviderDesc {
+    pub id: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+    pub icon: String,
+    pub position: String,
+}

crates/owlry-core/src/lib.rs

@@ -0,0 +1,9 @@
+pub mod config;
+pub mod data;
+pub mod filter;
+pub mod ipc;
+pub mod notify;
+pub mod paths;
+pub mod plugins;
+pub mod providers;
+pub mod server;

crates/owlry-core/src/main.rs

@@ -0,0 +1,39 @@
+use log::{info, warn};
+
+use owlry_core::paths;
+use owlry_core::server::Server;
+
+fn main() {
+    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("warn")).init();
+
+    let sock = paths::socket_path();
+    info!("Starting owlryd daemon...");
+
+    // Ensure the socket parent directory exists
+    if let Err(e) = paths::ensure_parent_dir(&sock) {
+        eprintln!("Failed to create socket directory: {e}");
+        std::process::exit(1);
+    }
+
+    let server = match Server::bind(&sock) {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("Failed to start owlryd: {e}");
+            std::process::exit(1);
+        }
+    };
+
+    // Graceful shutdown on SIGTERM/SIGINT
+    let sock_cleanup = sock.clone();
+    if let Err(e) = ctrlc::set_handler(move || {
+        let _ = std::fs::remove_file(&sock_cleanup);
+        std::process::exit(0);
+    }) {
+        warn!("Failed to set signal handler: {}", e);
+    }
+
+    if let Err(e) = server.run() {
+        eprintln!("Server error: {e}");
+        std::process::exit(1);
+    }
+}

crates/owlry-core/src/paths.rs

@@ -32,7 +32,6 @@ pub fn cache_home() -> Option<PathBuf> {
     dirs::cache_dir()
 }
 
-
 // =============================================================================
 // Owlry-specific directories
 // =============================================================================
@@ -154,6 +153,20 @@ pub fn system_data_dirs() -> Vec<PathBuf> {
     dirs
 }
 
+// =============================================================================
+// Runtime files
+// =============================================================================
+
+/// IPC socket path: `$XDG_RUNTIME_DIR/owlry/owlry.sock`
+///
+/// Falls back to `/tmp` if `$XDG_RUNTIME_DIR` is not set.
+pub fn socket_path() -> PathBuf {
+    let runtime_dir = std::env::var("XDG_RUNTIME_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| PathBuf::from("/tmp"));
+    runtime_dir.join(APP_NAME).join("owlry.sock")
+}
+
 // =============================================================================
 // Helper functions
 // =============================================================================
@@ -161,9 +174,10 @@ pub fn system_data_dirs() -> Vec<PathBuf> {
 /// Ensure parent directory of a file exists
 pub fn ensure_parent_dir(path: &std::path::Path) -> std::io::Result<()> {
     if let Some(parent) = path.parent()
-        && !parent.exists() {
-            std::fs::create_dir_all(parent)?;
-        }
+        && !parent.exists()
+    {
+        std::fs::create_dir_all(parent)?;
+    }
     Ok(())
 }
 

crates/owlry-core/src/plugins/api/action.rs

@@ -54,9 +54,9 @@ pub fn register_action_api(lua: &Lua, owlry: &Table, plugin_id: &str) -> LuaResu
                 .get("name")
                 .map_err(|_| mlua::Error::external("action.register: 'name' is required"))?;
 
-            let _handler: Function = config
-                .get("handler")
-                .map_err(|_| mlua::Error::external("action.register: 'handler' function is required"))?;
+            let _handler: Function = config.get("handler").map_err(|_| {
+                mlua::Error::external("action.register: 'handler' function is required")
+            })?;
 
             // Extract optional fields
             let icon: Option<String> = config.get("icon").ok();
@@ -166,7 +166,7 @@ pub fn get_actions_for_item(lua: &Lua, item: &Table) -> LuaResult<Vec<ActionRegi
         // Check filter if present
         if let Ok(filter) = entry.get::<Function>("filter") {
             match filter.call::<bool>(item.clone()) {
-                Ok(true) => {} // Include this action
+                Ok(true) => {}         // Include this action
                 Ok(false) => continue, // Skip this action
                 Err(e) => {
                     log::warn!("Action filter failed: {}", e);
@@ -220,7 +220,8 @@ mod tests {
     fn test_action_registration() {
         let lua = setup_lua("test-plugin");
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             return owlry.action.register({
                 id = "copy-name",
                 name = "Copy Name",
@@ -229,7 +230,8 @@ mod tests {
                     -- copy logic here
                 end
             })
-        "#);
+        "#,
+        );
         let action_id: String = chunk.call(()).unwrap();
         assert_eq!(action_id, "test-plugin:copy-name");
 
@@ -243,7 +245,8 @@ mod tests {
     fn test_action_with_filter() {
         let lua = setup_lua("test-plugin");
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             owlry.action.register({
                 id = "bookmark-action",
                 name = "Open in Browser",
@@ -252,7 +255,8 @@ mod tests {
                 end,
                 handler = function(item) end
             })
-        "#);
+        "#,
+        );
         chunk.call::<()>(()).unwrap();
 
         // Create bookmark item
@@ -276,14 +280,16 @@ mod tests {
     fn test_action_unregister() {
         let lua = setup_lua("test-plugin");
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             owlry.action.register({
                 id = "temp-action",
                 name = "Temporary",
                 handler = function(item) end
             })
             return owlry.action.unregister("temp-action")
-        "#);
+        "#,
+        );
         let unregistered: bool = chunk.call(()).unwrap();
         assert!(unregistered);
 
@@ -296,7 +302,8 @@ mod tests {
         let lua = setup_lua("test-plugin");
 
         // Register action that sets a global
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             result = nil
             owlry.action.register({
                 id = "test-exec",
@@ -305,7 +312,8 @@ mod tests {
                     result = item.name
                 end
             })
-        "#);
+        "#,
+        );
         chunk.call::<()>(()).unwrap();
 
         // Create test item

crates/owlry-core/src/plugins/api/cache.rs

@@ -35,9 +35,9 @@ pub fn register_cache_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     cache_table.set(
         "get",
         lua.create_function(|lua, key: String| {
-            let cache = CACHE.lock().map_err(|e| {
-                mlua::Error::external(format!("Failed to lock cache: {}", e))
-            })?;
+            let cache = CACHE
+                .lock()
+                .map_err(|e| mlua::Error::external(format!("Failed to lock cache: {}", e)))?;
 
             if let Some(entry) = cache.get(&key) {
                 if entry.is_expired() {
@@ -50,8 +50,10 @@ pub fn register_cache_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
                 }
 
                 // Parse JSON back to Lua value
-                let json_value: serde_json::Value = serde_json::from_str(&entry.value)
-                    .map_err(|e| mlua::Error::external(format!("Failed to parse cached value: {}", e)))?;
+                let json_value: serde_json::Value =
+                    serde_json::from_str(&entry.value).map_err(|e| {
+                        mlua::Error::external(format!("Failed to parse cached value: {}", e))
+                    })?;
 
                 json_to_lua(lua, &json_value)
             } else {
@@ -75,9 +77,9 @@ pub fn register_cache_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
                 expires_at,
             };
 
-            let mut cache = CACHE.lock().map_err(|e| {
-                mlua::Error::external(format!("Failed to lock cache: {}", e))
-            })?;
+            let mut cache = CACHE
+                .lock()
+                .map_err(|e| mlua::Error::external(format!("Failed to lock cache: {}", e)))?;
 
             cache.insert(key, entry);
             Ok(true)
@@ -88,9 +90,9 @@ pub fn register_cache_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     cache_table.set(
         "delete",
         lua.create_function(|_lua, key: String| {
-            let mut cache = CACHE.lock().map_err(|e| {
-                mlua::Error::external(format!("Failed to lock cache: {}", e))
-            })?;
+            let mut cache = CACHE
+                .lock()
+                .map_err(|e| mlua::Error::external(format!("Failed to lock cache: {}", e)))?;
 
             Ok(cache.remove(&key).is_some())
         })?,
@@ -100,9 +102,9 @@ pub fn register_cache_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     cache_table.set(
         "clear",
         lua.create_function(|_lua, ()| {
-            let mut cache = CACHE.lock().map_err(|e| {
-                mlua::Error::external(format!("Failed to lock cache: {}", e))
-            })?;
+            let mut cache = CACHE
+                .lock()
+                .map_err(|e| mlua::Error::external(format!("Failed to lock cache: {}", e)))?;
 
             let count = cache.len();
             cache.clear();
@@ -114,9 +116,9 @@ pub fn register_cache_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     cache_table.set(
         "has",
         lua.create_function(|_lua, key: String| {
-            let cache = CACHE.lock().map_err(|e| {
-                mlua::Error::external(format!("Failed to lock cache: {}", e))
-            })?;
+            let cache = CACHE
+                .lock()
+                .map_err(|e| mlua::Error::external(format!("Failed to lock cache: {}", e)))?;
 
             if let Some(entry) = cache.get(&key) {
                 Ok(!entry.is_expired())
@@ -249,10 +251,12 @@ mod tests {
         let _: bool = chunk.call(()).unwrap();
 
         // Get and verify
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             local t = owlry.cache.get("table_key")
             return t.name, t.value
-        "#);
+        "#,
+        );
         let (name, value): (String, i32) = chunk.call(()).unwrap();
         assert_eq!(name, "test");
         assert_eq!(value, 42);
@@ -262,12 +266,14 @@ mod tests {
     fn test_cache_delete() {
         let lua = setup_lua();
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             owlry.cache.set("delete_key", "value")
             local existed = owlry.cache.delete("delete_key")
             local value = owlry.cache.get("delete_key")
             return existed, value
-        "#);
+        "#,
+        );
         let (existed, value): (bool, Option<String>) = chunk.call(()).unwrap();
         assert!(existed);
         assert!(value.is_none());
@@ -277,12 +283,14 @@ mod tests {
     fn test_cache_has() {
         let lua = setup_lua();
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             local before = owlry.cache.has("has_key")
             owlry.cache.set("has_key", "value")
             local after = owlry.cache.has("has_key")
             return before, after
-        "#);
+        "#,
+        );
         let (before, after): (bool, bool) = chunk.call(()).unwrap();
         assert!(!before);
         assert!(after);

crates/owlry-core/src/plugins/api/hook.rs

@@ -329,13 +329,15 @@ mod tests {
         clear_all_hooks();
         let lua = setup_lua("test-plugin");
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             local called = false
             owlry.hook.on("init", function()
                 called = true
             end)
             return true
-        "#);
+        "#,
+        );
         let result: bool = chunk.call(()).unwrap();
         assert!(result);
 
@@ -349,11 +351,13 @@ mod tests {
         clear_all_hooks();
         let lua = setup_lua("test-plugin");
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             owlry.hook.on("query", function(q) return q .. "1" end, 10)
             owlry.hook.on("query", function(q) return q .. "2" end, 20)
             return true
-        "#);
+        "#,
+        );
         chunk.call::<()>(()).unwrap();
 
         // Call hooks - higher priority (20) should run first
@@ -367,11 +371,13 @@ mod tests {
         clear_all_hooks();
         let lua = setup_lua("test-plugin");
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             owlry.hook.on("select", function() end)
             owlry.hook.off("select")
             return true
-        "#);
+        "#,
+        );
         chunk.call::<()>(()).unwrap();
 
         let plugins = get_registered_plugins(HookEvent::Select);
@@ -383,14 +389,16 @@ mod tests {
         clear_all_hooks();
         let lua = setup_lua("test-plugin");
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             owlry.hook.on("pre_launch", function(item)
                 if item.name == "blocked" then
                     return false -- cancel launch
                 end
                 return true
             end)
-        "#);
+        "#,
+        );
         chunk.call::<()>(()).unwrap();
 
         // Create a test item table

crates/owlry-core/src/plugins/api/http.rs

@@ -26,18 +26,21 @@ pub fn register_http_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
             let client = reqwest::blocking::Client::builder()
                 .timeout(Duration::from_secs(timeout_secs))
                 .build()
-                .map_err(|e| mlua::Error::external(format!("Failed to create HTTP client: {}", e)))?;
+                .map_err(|e| {
+                    mlua::Error::external(format!("Failed to create HTTP client: {}", e))
+                })?;
 
             let mut request = client.get(&url);
 
             // Add custom headers if provided
             if let Some(ref opts) = opts
-                && let Ok(headers) = opts.get::<Table>("headers") {
-                    for pair in headers.pairs::<String, String>() {
-                        let (key, value) = pair?;
-                        request = request.header(&key, &value);
-                    }
+                && let Ok(headers) = opts.get::<Table>("headers")
+            {
+                for pair in headers.pairs::<String, String>() {
+                    let (key, value) = pair?;
+                    request = request.header(&key, &value);
                 }
+            }
 
             let response = request
                 .send()
@@ -45,9 +48,9 @@ pub fn register_http_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
 
             let status = response.status().as_u16();
             let headers = extract_headers(&response);
-            let body = response
-                .text()
-                .map_err(|e| mlua::Error::external(format!("Failed to read response body: {}", e)))?;
+            let body = response.text().map_err(|e| {
+                mlua::Error::external(format!("Failed to read response body: {}", e))
+            })?;
 
             let result = lua.create_table()?;
             result.set("status", status)?;
@@ -78,18 +81,21 @@ pub fn register_http_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
             let client = reqwest::blocking::Client::builder()
                 .timeout(Duration::from_secs(timeout_secs))
                 .build()
-                .map_err(|e| mlua::Error::external(format!("Failed to create HTTP client: {}", e)))?;
+                .map_err(|e| {
+                    mlua::Error::external(format!("Failed to create HTTP client: {}", e))
+                })?;
 
             let mut request = client.post(&url);
 
             // Add custom headers if provided
             if let Some(ref opts) = opts
-                && let Ok(headers) = opts.get::<Table>("headers") {
-                    for pair in headers.pairs::<String, String>() {
-                        let (key, value) = pair?;
-                        request = request.header(&key, &value);
-                    }
+                && let Ok(headers) = opts.get::<Table>("headers")
+            {
+                for pair in headers.pairs::<String, String>() {
+                    let (key, value) = pair?;
+                    request = request.header(&key, &value);
                 }
+            }
 
             // Set body based on type
             request = match body {
@@ -102,11 +108,7 @@ pub fn register_http_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
                         .body(json_str)
                 }
                 Value::Nil => request,
-                _ => {
-                    return Err(mlua::Error::external(
-                        "POST body must be a string or table",
-                    ))
-                }
+                _ => return Err(mlua::Error::external("POST body must be a string or table")),
             };
 
             let response = request
@@ -115,9 +117,9 @@ pub fn register_http_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
 
             let status = response.status().as_u16();
             let headers = extract_headers(&response);
-            let body = response
-                .text()
-                .map_err(|e| mlua::Error::external(format!("Failed to read response body: {}", e)))?;
+            let body = response.text().map_err(|e| {
+                mlua::Error::external(format!("Failed to read response body: {}", e))
+            })?;
 
             let result = lua.create_table()?;
             result.set("status", status)?;
@@ -149,19 +151,22 @@ pub fn register_http_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
             let client = reqwest::blocking::Client::builder()
                 .timeout(Duration::from_secs(timeout_secs))
                 .build()
-                .map_err(|e| mlua::Error::external(format!("Failed to create HTTP client: {}", e)))?;
+                .map_err(|e| {
+                    mlua::Error::external(format!("Failed to create HTTP client: {}", e))
+                })?;
 
             let mut request = client.get(&url);
             request = request.header("Accept", "application/json");
 
             // Add custom headers if provided
             if let Some(ref opts) = opts
-                && let Ok(headers) = opts.get::<Table>("headers") {
-                    for pair in headers.pairs::<String, String>() {
-                        let (key, value) = pair?;
-                        request = request.header(&key, &value);
-                    }
+                && let Ok(headers) = opts.get::<Table>("headers")
+            {
+                for pair in headers.pairs::<String, String>() {
+                    let (key, value) = pair?;
+                    request = request.header(&key, &value);
                 }
+            }
 
             let response = request
                 .send()
@@ -174,9 +179,9 @@ pub fn register_http_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
                 )));
             }
 
-            let body = response
-                .text()
-                .map_err(|e| mlua::Error::external(format!("Failed to read response body: {}", e)))?;
+            let body = response.text().map_err(|e| {
+                mlua::Error::external(format!("Failed to read response body: {}", e))
+            })?;
 
             // Parse JSON and convert to Lua table
             let json_value: serde_json::Value = serde_json::from_str(&body)

crates/owlry-core/src/plugins/api/math.rs

@@ -14,20 +14,20 @@ pub fn register_math_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     // Returns (result, nil) on success or (nil, error_message) on failure
     math_table.set(
         "calculate",
-        lua.create_function(|_lua, expr: String| -> LuaResult<(Option<f64>, Option<String>)> {
-            match meval::eval_str(&expr) {
-                Ok(result) => {
-                    if result.is_finite() {
-                        Ok((Some(result), None))
-                    } else {
-                        Ok((None, Some("Result is not a finite number".to_string())))
+        lua.create_function(
+            |_lua, expr: String| -> LuaResult<(Option<f64>, Option<String>)> {
+                match meval::eval_str(&expr) {
+                    Ok(result) => {
+                        if result.is_finite() {
+                            Ok((Some(result), None))
+                        } else {
+                            Ok((None, Some("Result is not a finite number".to_string())))
+                        }
                     }
+                    Err(e) => Ok((None, Some(e.to_string()))),
                 }
-                Err(e) => {
-                    Ok((None, Some(e.to_string())))
-                }
-            }
-        })?,
+            },
+        )?,
     )?;
 
     // owlry.math.calc(expression) -> number (throws on error)
@@ -106,11 +106,13 @@ mod tests {
     fn test_calculate_basic() {
         let lua = setup_lua();
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             local result, err = owlry.math.calculate("2 + 2")
             if err then error(err) end
             return result
-        "#);
+        "#,
+        );
         let result: f64 = chunk.call(()).unwrap();
         assert!((result - 4.0).abs() < f64::EPSILON);
     }
@@ -119,11 +121,13 @@ mod tests {
     fn test_calculate_complex() {
         let lua = setup_lua();
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             local result, err = owlry.math.calculate("sqrt(16) + 2^3")
             if err then error(err) end
             return result
-        "#);
+        "#,
+        );
         let result: f64 = chunk.call(()).unwrap();
         assert!((result - 12.0).abs() < f64::EPSILON); // sqrt(16) = 4, 2^3 = 8
     }
@@ -132,14 +136,16 @@ mod tests {
     fn test_calculate_error() {
         let lua = setup_lua();
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             local result, err = owlry.math.calculate("invalid expression @@")
             if result then
                 return false -- should not succeed
             else
                 return true -- correctly failed
             end
-        "#);
+        "#,
+        );
         let had_error: bool = chunk.call(()).unwrap();
         assert!(had_error);
     }

crates/owlry-core/src/plugins/api/process.rs

@@ -27,8 +27,14 @@ pub fn register_process_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
                 .map_err(|e| mlua::Error::external(format!("Failed to run command: {}", e)))?;
 
             let result = lua.create_table()?;
-            result.set("stdout", String::from_utf8_lossy(&output.stdout).to_string())?;
-            result.set("stderr", String::from_utf8_lossy(&output.stderr).to_string())?;
+            result.set(
+                "stdout",
+                String::from_utf8_lossy(&output.stdout).to_string(),
+            )?;
+            result.set(
+                "stderr",
+                String::from_utf8_lossy(&output.stderr).to_string(),
+            )?;
             result.set("exit_code", output.status.code().unwrap_or(-1))?;
             result.set("success", output.status.success())?;
 
@@ -95,9 +101,7 @@ pub fn register_env_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     // owlry.env.get(name) -> string or nil
     env_table.set(
         "get",
-        lua.create_function(|_lua, name: String| {
-            Ok(std::env::var(&name).ok())
-        })?,
+        lua.create_function(|_lua, name: String| Ok(std::env::var(&name).ok()))?,
     )?;
 
     // owlry.env.get_or(name, default) -> string
@@ -166,7 +170,8 @@ mod tests {
         assert!(exists);
 
         // Made-up command should not exist
-        let chunk = lua.load(r#"return owlry.process.exists("this_command_definitely_does_not_exist_12345")"#);
+        let chunk = lua
+            .load(r#"return owlry.process.exists("this_command_definitely_does_not_exist_12345")"#);
         let not_exists: bool = chunk.call(()).unwrap();
         assert!(!not_exists);
     }
@@ -190,7 +195,8 @@ mod tests {
     fn test_env_get_or() {
         let lua = setup_lua();
 
-        let chunk = lua.load(r#"return owlry.env.get_or("THIS_VAR_DOES_NOT_EXIST_12345", "default_value")"#);
+        let chunk = lua
+            .load(r#"return owlry.env.get_or("THIS_VAR_DOES_NOT_EXIST_12345", "default_value")"#);
         let result: String = chunk.call(()).unwrap();
         assert_eq!(result, "default_value");
     }

crates/owlry-core/src/plugins/api/theme.rs

@@ -21,7 +21,12 @@ pub struct ThemeRegistration {
 }
 
 /// Register theme APIs
-pub fn register_theme_api(lua: &Lua, owlry: &Table, plugin_id: &str, plugin_dir: &Path) -> LuaResult<()> {
+pub fn register_theme_api(
+    lua: &Lua,
+    owlry: &Table,
+    plugin_id: &str,
+    plugin_dir: &Path,
+) -> LuaResult<()> {
     let theme_table = lua.create_table()?;
     let plugin_id_owned = plugin_id.to_string();
     let plugin_dir_owned = plugin_dir.to_path_buf();
@@ -50,9 +55,7 @@ pub fn register_theme_api(lua: &Lua, owlry: &Table, plugin_id: &str, plugin_dir:
                 .get("name")
                 .map_err(|_| mlua::Error::external("theme.register: 'name' is required"))?;
 
-            let display_name: String = config
-                .get("display_name")
-                .unwrap_or_else(|_| name.clone());
+            let display_name: String = config.get("display_name").unwrap_or_else(|_| name.clone());
 
             // Get CSS either directly or from file
             let css: String = if let Ok(css_str) = config.get::<String>("css") {
@@ -197,13 +200,15 @@ mod tests {
         let temp = TempDir::new().unwrap();
         let lua = setup_lua("test-plugin", temp.path());
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             return owlry.theme.register({
                 name = "my-theme",
                 display_name = "My Theme",
                 css = ".owlry-window { background: #333; }"
             })
-        "#);
+        "#,
+        );
         let name: String = chunk.call(()).unwrap();
         assert_eq!(name, "my-theme");
 
@@ -221,12 +226,14 @@ mod tests {
 
         let lua = setup_lua("test-plugin", temp.path());
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             return owlry.theme.register({
                 name = "file-theme",
                 css_file = "theme.css"
             })
-        "#);
+        "#,
+        );
         let name: String = chunk.call(()).unwrap();
         assert_eq!(name, "file-theme");
 
@@ -240,11 +247,13 @@ mod tests {
         let temp = TempDir::new().unwrap();
         let lua = setup_lua("test-plugin", temp.path());
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             owlry.theme.register({ name = "theme1", css = "a{}" })
             owlry.theme.register({ name = "theme2", css = "b{}" })
             return owlry.theme.list()
-        "#);
+        "#,
+        );
         let list: Table = chunk.call(()).unwrap();
 
         let mut names: Vec<String> = Vec::new();
@@ -262,10 +271,12 @@ mod tests {
         let temp = TempDir::new().unwrap();
         let lua = setup_lua("test-plugin", temp.path());
 
-        let chunk = lua.load(r#"
+        let chunk = lua.load(
+            r#"
             owlry.theme.register({ name = "temp-theme", css = "c{}" })
             return owlry.theme.unregister("temp-theme")
-        "#);
+        "#,
+        );
         let unregistered: bool = chunk.call(()).unwrap();
         assert!(unregistered);
 

crates/owlry-core/src/plugins/api/utils.rs

@@ -189,9 +189,10 @@ pub fn register_fs_api(lua: &Lua, owlry: &Table, plugin_dir: &Path) -> LuaResult
             // Ensure parent directory exists
             if let Some(parent) = full_path.parent()
                 && !parent.exists()
-                    && let Err(e) = std::fs::create_dir_all(parent) {
-                        return Ok((false, Value::String(lua.create_string(e.to_string())?)));
-                    }
+                && let Err(e) = std::fs::create_dir_all(parent)
+            {
+                return Ok((false, Value::String(lua.create_string(e.to_string())?)));
+            }
 
             match std::fs::write(&full_path, content) {
                 Ok(()) => Ok((true, Value::Nil)),
@@ -295,7 +296,8 @@ pub fn register_fs_api(lua: &Lua, owlry: &Table, plugin_dir: &Path) -> LuaResult
             use std::os::unix::fs::PermissionsExt;
             let plugin_dir: String = lua.named_registry_value("plugin_dir")?;
             let full_path = resolve_plugin_path(&plugin_dir, &path);
-            let is_exec = full_path.metadata()
+            let is_exec = full_path
+                .metadata()
                 .map(|m| m.permissions().mode() & 0o111 != 0)
                 .unwrap_or(false);
             Ok(is_exec)
@@ -335,28 +337,24 @@ pub fn register_json_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     // owlry.json.encode(value) -> string or nil, error
     json_table.set(
         "encode",
-        lua.create_function(|lua, value: Value| {
-            match lua_to_json(&value) {
-                Ok(json) => match serde_json::to_string(&json) {
-                    Ok(s) => Ok((Some(s), Value::Nil)),
-                    Err(e) => Ok((None, Value::String(lua.create_string(e.to_string())?))),
-                },
-                Err(e) => Ok((None, Value::String(lua.create_string(&e)?))),
-            }
+        lua.create_function(|lua, value: Value| match lua_to_json(&value) {
+            Ok(json) => match serde_json::to_string(&json) {
+                Ok(s) => Ok((Some(s), Value::Nil)),
+                Err(e) => Ok((None, Value::String(lua.create_string(e.to_string())?))),
+            },
+            Err(e) => Ok((None, Value::String(lua.create_string(&e)?))),
         })?,
     )?;
 
     // owlry.json.encode_pretty(value) -> string or nil, error
     json_table.set(
         "encode_pretty",
-        lua.create_function(|lua, value: Value| {
-            match lua_to_json(&value) {
-                Ok(json) => match serde_json::to_string_pretty(&json) {
-                    Ok(s) => Ok((Some(s), Value::Nil)),
-                    Err(e) => Ok((None, Value::String(lua.create_string(e.to_string())?))),
-                },
-                Err(e) => Ok((None, Value::String(lua.create_string(&e)?))),
-            }
+        lua.create_function(|lua, value: Value| match lua_to_json(&value) {
+            Ok(json) => match serde_json::to_string_pretty(&json) {
+                Ok(s) => Ok((Some(s), Value::Nil)),
+                Err(e) => Ok((None, Value::String(lua.create_string(e.to_string())?))),
+            },
+            Err(e) => Ok((None, Value::String(lua.create_string(&e)?))),
         })?,
     )?;
 
@@ -388,13 +386,16 @@ fn lua_to_json(value: &Value) -> Result<serde_json::Value, String> {
             .map(serde_json::Value::Number)
             .ok_or_else(|| "Invalid number".to_string()),
         Value::String(s) => Ok(serde_json::Value::String(
-            s.to_str().map_err(|e| e.to_string())?.to_string()
+            s.to_str().map_err(|e| e.to_string())?.to_string(),
         )),
         Value::Table(t) => {
             // Check if it's an array (sequential integer keys starting from 1)
             let len = t.raw_len();
             let is_array = len > 0
-                && (1..=len).all(|i| t.raw_get::<Value>(i).is_ok_and(|v| !matches!(v, Value::Nil)));
+                && (1..=len).all(|i| {
+                    t.raw_get::<Value>(i)
+                        .is_ok_and(|v| !matches!(v, Value::Nil))
+                });
 
             if is_array {
                 let arr: Result<Vec<serde_json::Value>, String> = (1..=len)
@@ -475,9 +476,13 @@ mod tests {
     fn test_log_api() {
         let (lua, _temp) = create_test_lua();
         // Just verify it doesn't panic - using call instead of the e-word
-        lua.load("owlry.log.info('test message')").call::<()>(()).unwrap();
+        lua.load("owlry.log.info('test message')")
+            .call::<()>(())
+            .unwrap();
         lua.load("owlry.log.debug('debug')").call::<()>(()).unwrap();
-        lua.load("owlry.log.warn('warning')").call::<()>(()).unwrap();
+        lua.load("owlry.log.warn('warning')")
+            .call::<()>(())
+            .unwrap();
         lua.load("owlry.log.error('error')").call::<()>(()).unwrap();
     }
 
@@ -485,10 +490,7 @@ mod tests {
     fn test_path_api() {
         let (lua, _temp) = create_test_lua();
 
-        let home: String = lua
-            .load("return owlry.path.home()")
-            .call(())
-            .unwrap();
+        let home: String = lua.load("return owlry.path.home()").call(()).unwrap();
         assert!(!home.is_empty());
 
         let joined: String = lua

crates/owlry-core/src/plugins/loader.rs

@@ -7,7 +7,7 @@ use mlua::Lua;
 use super::api;
 use super::error::{PluginError, PluginResult};
 use super::manifest::PluginManifest;
-use super::runtime::{create_lua_runtime, load_file, SandboxConfig};
+use super::runtime::{SandboxConfig, create_lua_runtime, load_file};
 
 /// A loaded plugin instance
 #[derive(Debug)]
@@ -94,7 +94,10 @@ impl LoadedPlugin {
     }
 
     /// Call a provider's refresh function
-    pub fn call_provider_refresh(&self, provider_name: &str) -> PluginResult<Vec<super::PluginItem>> {
+    pub fn call_provider_refresh(
+        &self,
+        provider_name: &str,
+    ) -> PluginResult<Vec<super::PluginItem>> {
         let lua = self.lua.as_ref().ok_or_else(|| PluginError::LuaError {
             plugin: self.id().to_string(),
             message: "Plugin not initialized".to_string(),
@@ -108,7 +111,11 @@ impl LoadedPlugin {
 
     /// Call a provider's query function
     #[allow(dead_code)] // Will be used for dynamic query providers
-    pub fn call_provider_query(&self, provider_name: &str, query: &str) -> PluginResult<Vec<super::PluginItem>> {
+    pub fn call_provider_query(
+        &self,
+        provider_name: &str,
+        query: &str,
+    ) -> PluginResult<Vec<super::PluginItem>> {
         let lua = self.lua.as_ref().ok_or_else(|| PluginError::LuaError {
             plugin: self.id().to_string(),
             message: "Plugin not initialized".to_string(),
@@ -138,8 +145,8 @@ impl LoadedPlugin {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use super::super::manifest::{check_compatibility, discover_plugins};
+    use super::*;
     use std::fs;
     use std::path::Path;
     use tempfile::TempDir;

crates/owlry-core/src/plugins/manifest.rs

@@ -112,11 +112,16 @@ pub struct PluginPermissions {
 /// Discover all plugins in a directory
 ///
 /// Returns a map of plugin ID -> (manifest, path)
-pub fn discover_plugins(plugins_dir: &Path) -> PluginResult<HashMap<String, (PluginManifest, PathBuf)>> {
+pub fn discover_plugins(
+    plugins_dir: &Path,
+) -> PluginResult<HashMap<String, (PluginManifest, PathBuf)>> {
     let mut plugins = HashMap::new();
 
     if !plugins_dir.exists() {
-        log::debug!("Plugins directory does not exist: {}", plugins_dir.display());
+        log::debug!(
+            "Plugins directory does not exist: {}",
+            plugins_dir.display()
+        );
         return Ok(plugins);
     }
 
@@ -143,7 +148,11 @@ pub fn discover_plugins(plugins_dir: &Path) -> PluginResult<HashMap<String, (Plu
                     log::warn!("Duplicate plugin ID '{}', skipping {}", id, path.display());
                     continue;
                 }
-                log::info!("Discovered plugin: {} v{}", manifest.plugin.name, manifest.plugin.version);
+                log::info!(
+                    "Discovered plugin: {} v{}",
+                    manifest.plugin.name,
+                    manifest.plugin.version
+                );
                 plugins.insert(id, (manifest, path));
             }
             Err(e) => {
@@ -204,7 +213,12 @@ impl PluginManifest {
             });
         }
 
-        if !self.plugin.id.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-') {
+        if !self
+            .plugin
+            .id
+            .chars()
+            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
+        {
             return Err(PluginError::InvalidManifest {
                 plugin: self.plugin.id.clone(),
                 message: "Plugin ID must be lowercase alphanumeric with hyphens".to_string(),
@@ -223,7 +237,10 @@ impl PluginManifest {
         if semver::VersionReq::parse(&self.plugin.owlry_version).is_err() {
             return Err(PluginError::InvalidManifest {
                 plugin: self.plugin.id.clone(),
-                message: format!("Invalid owlry_version constraint: {}", self.plugin.owlry_version),
+                message: format!(
+                    "Invalid owlry_version constraint: {}",
+                    self.plugin.owlry_version
+                ),
             });
         }
 

crates/owlry-core/src/plugins/mod.rs

@@ -21,12 +21,12 @@
 //! ```
 
 // Always available
-pub mod commands;
 pub mod error;
 pub mod manifest;
 pub mod native_loader;
 pub mod registry;
 pub mod runtime_loader;
+pub mod watcher;
 
 // Lua-specific modules (require mlua)
 #[cfg(feature = "lua")]
@@ -51,7 +51,7 @@ pub use loader::LoadedPlugin;
 
 // Used by plugins/commands.rs for plugin CLI commands
 #[allow(unused_imports)]
-pub use manifest::{check_compatibility, discover_plugins, PluginManifest};
+pub use manifest::{PluginManifest, check_compatibility, discover_plugins};
 
 // ============================================================================
 // Lua Plugin Manager (only available with lua feature)
@@ -65,7 +65,7 @@ mod lua_manager {
     use std::path::PathBuf;
     use std::rc::Rc;
 
-    use manifest::{discover_plugins, check_compatibility};
+    use manifest::{check_compatibility, discover_plugins};
 
     /// Plugin manager coordinates loading, initialization, and lifecycle of Lua plugins
     pub struct PluginManager {
@@ -159,7 +159,10 @@ mod lua_manager {
 
         /// Get all enabled plugins
         pub fn enabled_plugins(&self) -> impl Iterator<Item = Rc<RefCell<LoadedPlugin>>> + '_ {
-            self.plugins.values().filter(|p| p.borrow().enabled).cloned()
+            self.plugins
+                .values()
+                .filter(|p| p.borrow().enabled)
+                .cloned()
         }
 
         /// Get the number of loaded plugins
@@ -177,7 +180,10 @@ mod lua_manager {
         /// Enable a plugin by ID
         #[allow(dead_code)]
         pub fn enable(&mut self, id: &str) -> PluginResult<()> {
-            let plugin_rc = self.plugins.get(id).ok_or_else(|| PluginError::NotFound(id.to_string()))?;
+            let plugin_rc = self
+                .plugins
+                .get(id)
+                .ok_or_else(|| PluginError::NotFound(id.to_string()))?;
             let mut plugin = plugin_rc.borrow_mut();
 
             if !plugin.enabled {
@@ -192,7 +198,10 @@ mod lua_manager {
         /// Disable a plugin by ID
         #[allow(dead_code)]
         pub fn disable(&mut self, id: &str) -> PluginResult<()> {
-            let plugin_rc = self.plugins.get(id).ok_or_else(|| PluginError::NotFound(id.to_string()))?;
+            let plugin_rc = self
+                .plugins
+                .get(id)
+                .ok_or_else(|| PluginError::NotFound(id.to_string()))?;
             plugin_rc.borrow_mut().enabled = false;
             Ok(())
         }
@@ -201,7 +210,13 @@ mod lua_manager {
         #[allow(dead_code)]
         pub fn providers_for(&self, provider_name: &str) -> Vec<String> {
             self.enabled_plugins()
-                .filter(|p| p.borrow().manifest.provides.providers.contains(&provider_name.to_string()))
+                .filter(|p| {
+                    p.borrow()
+                        .manifest
+                        .provides
+                        .providers
+                        .contains(&provider_name.to_string())
+                })
                 .map(|p| p.borrow().id().to_string())
                 .collect()
         }
@@ -209,13 +224,15 @@ mod lua_manager {
         /// Check if any plugin provides actions
         #[allow(dead_code)]
         pub fn has_action_plugins(&self) -> bool {
-            self.enabled_plugins().any(|p| p.borrow().manifest.provides.actions)
+            self.enabled_plugins()
+                .any(|p| p.borrow().manifest.provides.actions)
         }
 
         /// Check if any plugin provides hooks
         #[allow(dead_code)]
         pub fn has_hook_plugins(&self) -> bool {
-            self.enabled_plugins().any(|p| p.borrow().manifest.provides.hooks)
+            self.enabled_plugins()
+                .any(|p| p.borrow().manifest.provides.hooks)
         }
 
         /// Get all theme names provided by plugins

crates/owlry-core/src/plugins/native_loader.rs

@@ -17,8 +17,8 @@ use std::sync::{Arc, Once};
 use libloading::Library;
 use log::{debug, error, info, warn};
 use owlry_plugin_api::{
-    HostAPI, NotifyUrgency, PluginInfo, PluginVTable, ProviderHandle, ProviderInfo, ProviderKind,
-    RStr, API_VERSION,
+    API_VERSION, HostAPI, NotifyUrgency, PluginInfo, PluginVTable, ProviderHandle, ProviderInfo,
+    ProviderKind, RStr,
 };
 
 use crate::notify;
@@ -28,9 +28,18 @@ use crate::notify;
 // ============================================================================
 
 /// Host notification handler
-extern "C" fn host_notify(summary: RStr<'_>, body: RStr<'_>, icon: RStr<'_>, urgency: NotifyUrgency) {
+extern "C" fn host_notify(
+    summary: RStr<'_>,
+    body: RStr<'_>,
+    icon: RStr<'_>,
+    urgency: NotifyUrgency,
+) {
     let icon_str = icon.as_str();
-    let icon_opt = if icon_str.is_empty() { None } else { Some(icon_str) };
+    let icon_opt = if icon_str.is_empty() {
+        None
+    } else {
+        Some(icon_str)
+    };
 
     let notify_urgency = match urgency {
         NotifyUrgency::Low => notify::NotifyUrgency::Low,
@@ -121,7 +130,9 @@ impl NativePlugin {
         handle: ProviderHandle,
         query: &str,
     ) -> Vec<owlry_plugin_api::PluginItem> {
-        (self.vtable.provider_query)(handle, query.into()).into_iter().collect()
+        (self.vtable.provider_query)(handle, query.into())
+            .into_iter()
+            .collect()
     }
 
     /// Drop a provider handle

crates/owlry-core/src/plugins/registry.rs

@@ -110,9 +110,10 @@ impl RegistryClient {
 
         if let Ok(metadata) = fs::metadata(&cache_path)
             && let Ok(modified) = metadata.modified()
-                && let Ok(elapsed) = SystemTime::now().duration_since(modified) {
-                    return elapsed < CACHE_DURATION;
-                }
+            && let Ok(elapsed) = SystemTime::now().duration_since(modified)
+        {
+            return elapsed < CACHE_DURATION;
+        }
 
         false
     }
@@ -120,11 +121,13 @@ impl RegistryClient {
     /// Fetch the registry index (from cache or network)
     pub fn fetch_index(&self, force_refresh: bool) -> Result<RegistryIndex, String> {
         // Use cache if valid and not forcing refresh
-        if !force_refresh && self.is_cache_valid()
+        if !force_refresh
+            && self.is_cache_valid()
             && let Ok(content) = fs::read_to_string(self.cache_path())
-                && let Ok(index) = toml::from_str(&content) {
-                    return Ok(index);
-                }
+            && let Ok(index) = toml::from_str(&content)
+        {
+            return Ok(index);
+        }
 
         // Fetch from network
         self.fetch_from_network()
@@ -134,12 +137,7 @@ impl RegistryClient {
     fn fetch_from_network(&self) -> Result<RegistryIndex, String> {
         // Use curl for fetching (available on most systems)
         let output = std::process::Command::new("curl")
-            .args([
-                "-fsSL",
-                "--max-time",
-                "30",
-                &self.registry_url,
-            ])
+            .args(["-fsSL", "--max-time", "30", &self.registry_url])
             .output()
             .map_err(|e| format!("Failed to run curl: {}", e))?;
 
@@ -185,7 +183,9 @@ impl RegistryClient {
                 p.id.to_lowercase().contains(&query_lower)
                     || p.name.to_lowercase().contains(&query_lower)
                     || p.description.to_lowercase().contains(&query_lower)
-                    || p.tags.iter().any(|t| t.to_lowercase().contains(&query_lower))
+                    || p.tags
+                        .iter()
+                        .any(|t| t.to_lowercase().contains(&query_lower))
             })
             .collect();
 
@@ -210,8 +210,7 @@ impl RegistryClient {
     pub fn clear_cache(&self) -> Result<(), String> {
         let cache_path = self.cache_path();
         if cache_path.exists() {
-            fs::remove_file(&cache_path)
-                .map_err(|e| format!("Failed to remove cache: {}", e))?;
+            fs::remove_file(&cache_path).map_err(|e| format!("Failed to remove cache: {}", e))?;
         }
         Ok(())
     }

crates/owlry-core/src/plugins/runtime.rs

@@ -26,7 +26,7 @@ impl Default for SandboxConfig {
             allow_commands: false,
             allow_network: false,
             allow_external_fs: false,
-            max_run_time_ms: 5000, // 5 seconds
+            max_run_time_ms: 5000,        // 5 seconds
             max_memory: 64 * 1024 * 1024, // 64 MB
         }
     }
@@ -49,11 +49,7 @@ pub fn create_lua_runtime(_sandbox: &SandboxConfig) -> LuaResult<Lua> {
     // Create Lua with safe standard libraries only
     // ALL_SAFE excludes: debug, io, os (dangerous parts), package (loadlib), ffi
     // We then customize the os table to only allow safe functions
-    let libs = StdLib::COROUTINE
-        | StdLib::TABLE
-        | StdLib::STRING
-        | StdLib::UTF8
-        | StdLib::MATH;
+    let libs = StdLib::COROUTINE | StdLib::TABLE | StdLib::STRING | StdLib::UTF8 | StdLib::MATH;
 
     let lua = Lua::new_with(libs, mlua::LuaOptions::default())?;
 
@@ -75,9 +71,15 @@ fn setup_safe_globals(lua: &Lua) -> LuaResult<()> {
     // We do NOT include: os.exit, os.remove, os.rename, os.setlocale, os.tmpname
     // and the shell-related functions
     let os_table = lua.create_table()?;
-    os_table.set("clock", lua.create_function(|_, ()| Ok(std::time::Instant::now().elapsed().as_secs_f64()))?)?;
+    os_table.set(
+        "clock",
+        lua.create_function(|_, ()| Ok(std::time::Instant::now().elapsed().as_secs_f64()))?,
+    )?;
     os_table.set("date", lua.create_function(os_date)?)?;
-    os_table.set("difftime", lua.create_function(|_, (t2, t1): (f64, f64)| Ok(t2 - t1))?)?;
+    os_table.set(
+        "difftime",
+        lua.create_function(|_, (t2, t1): (f64, f64)| Ok(t2 - t1))?,
+    )?;
     os_table.set("time", lua.create_function(os_time)?)?;
     globals.set("os", os_table)?;
 
@@ -107,8 +109,7 @@ fn os_time(_lua: &Lua, _args: ()) -> LuaResult<i64> {
 
 /// Load and run a Lua file in the given runtime
 pub fn load_file(lua: &Lua, path: &std::path::Path) -> LuaResult<()> {
-    let content = std::fs::read_to_string(path)
-        .map_err(mlua::Error::external)?;
+    let content = std::fs::read_to_string(path).map_err(mlua::Error::external)?;
     lua.load(&content)
         .set_name(path.file_name().and_then(|n| n.to_str()).unwrap_or("chunk"))
         .into_function()?

crates/owlry-core/src/plugins/runtime_loader.rs

@@ -10,8 +10,6 @@
 //! Note: This module is infrastructure for the runtime architecture. Full integration
 //! is pending Phase 5 (AUR Packaging) when runtime packages will be available.
 
-#![allow(dead_code)]
-
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
@@ -56,10 +54,14 @@ pub struct RuntimeHandle(pub *mut ());
 #[repr(C)]
 pub struct ScriptRuntimeVTable {
     pub info: extern "C" fn() -> RuntimeInfo,
-    pub init: extern "C" fn(plugins_dir: RStr<'_>) -> RuntimeHandle,
+    pub init: extern "C" fn(plugins_dir: RStr<'_>, owlry_version: RStr<'_>) -> RuntimeHandle,
     pub providers: extern "C" fn(handle: RuntimeHandle) -> RVec<ScriptProviderInfo>,
     pub refresh: extern "C" fn(handle: RuntimeHandle, provider_id: RStr<'_>) -> RVec<PluginItem>,
-    pub query: extern "C" fn(handle: RuntimeHandle, provider_id: RStr<'_>, query: RStr<'_>) -> RVec<PluginItem>,
+    pub query: extern "C" fn(
+        handle: RuntimeHandle,
+        provider_id: RStr<'_>,
+        query: RStr<'_>,
+    ) -> RVec<PluginItem>,
     pub drop: extern "C" fn(handle: RuntimeHandle),
 }
 
@@ -79,12 +81,13 @@ pub struct LoadedRuntime {
 
 impl LoadedRuntime {
     /// Load the Lua runtime from the system directory
-    pub fn load_lua(plugins_dir: &Path) -> PluginResult<Self> {
+    pub fn load_lua(plugins_dir: &Path, owlry_version: &str) -> PluginResult<Self> {
         Self::load_from_path(
             "Lua",
             &PathBuf::from(SYSTEM_RUNTIMES_DIR).join("liblua.so"),
             b"owlry_lua_runtime_vtable",
             plugins_dir,
+            owlry_version,
         )
     }
 
@@ -94,15 +97,15 @@ impl LoadedRuntime {
         library_path: &Path,
         vtable_symbol: &[u8],
         plugins_dir: &Path,
+        owlry_version: &str,
     ) -> PluginResult<Self> {
         if !library_path.exists() {
             return Err(PluginError::NotFound(library_path.display().to_string()));
         }
 
         // SAFETY: We trust the runtime library to be correct
-        let library = unsafe { Library::new(library_path) }.map_err(|e| {
-            PluginError::LoadError(format!("{}: {}", library_path.display(), e))
-        })?;
+        let library = unsafe { Library::new(library_path) }
+            .map_err(|e| PluginError::LoadError(format!("{}: {}", library_path.display(), e)))?;
 
         let library = Arc::new(library);
 
@@ -121,7 +124,7 @@ impl LoadedRuntime {
 
         // Initialize the runtime
         let plugins_dir_str = plugins_dir.to_string_lossy();
-        let handle = (vtable.init)(RStr::from_str(&plugins_dir_str));
+        let handle = (vtable.init)(RStr::from_str(&plugins_dir_str), RStr::from_str(owlry_version));
 
         // Get provider information
         let providers_rvec = (vtable.providers)(handle);
@@ -152,12 +155,8 @@ impl LoadedRuntime {
         self.providers
             .iter()
             .map(|info| {
-                let provider = RuntimeProvider::new(
-                    self.name,
-                    self.vtable,
-                    self.handle,
-                    info.clone(),
-                );
+                let provider =
+                    RuntimeProvider::new(self.name, self.vtable, self.handle, info.clone());
                 Box::new(provider) as Box<dyn Provider>
             })
             .collect()
@@ -170,6 +169,14 @@ impl Drop for LoadedRuntime {
     }
 }
 
+// LoadedRuntime needs to be Send + Sync because ProviderManager is shared across
+// threads via Arc<RwLock<ProviderManager>>.
+// Safety: RuntimeHandle is an opaque FFI handle accessed only through extern "C"
+// vtable functions. The same safety argument that applies to RuntimeProvider applies
+// here — all access is mediated by the vtable, and the runtime itself serializes access.
+unsafe impl Send for LoadedRuntime {}
+unsafe impl Sync for LoadedRuntime {}
+
 /// A provider backed by a dynamically loaded runtime
 pub struct RuntimeProvider {
     /// Runtime name (for logging)
@@ -227,7 +234,10 @@ impl Provider for RuntimeProvider {
 
         let name_rstr = RStr::from_str(self.info.name.as_str());
         let items_rvec = (self.vtable.refresh)(self.handle, name_rstr);
-        self.items = items_rvec.into_iter().map(|i| self.convert_item(i)).collect();
+        self.items = items_rvec
+            .into_iter()
+            .map(|i| self.convert_item(i))
+            .collect();
 
         log::debug!(
             "[RuntimeProvider] '{}' refreshed with {} items",
@@ -241,27 +251,36 @@ impl Provider for RuntimeProvider {
     }
 }
 
-// RuntimeProvider needs to be Send for the Provider trait
+// RuntimeProvider needs to be Send + Sync for the Provider trait.
+// Safety: RuntimeHandle is an opaque FFI handle accessed only through
+// extern "C" vtable functions. The same safety argument that justifies
+// Send applies to Sync — all access is mediated by the vtable.
 unsafe impl Send for RuntimeProvider {}
+unsafe impl Sync for RuntimeProvider {}
 
 /// Check if the Lua runtime is available
 pub fn lua_runtime_available() -> bool {
-    PathBuf::from(SYSTEM_RUNTIMES_DIR).join("liblua.so").exists()
+    PathBuf::from(SYSTEM_RUNTIMES_DIR)
+        .join("liblua.so")
+        .exists()
 }
 
 /// Check if the Rune runtime is available
 pub fn rune_runtime_available() -> bool {
-    PathBuf::from(SYSTEM_RUNTIMES_DIR).join("librune.so").exists()
+    PathBuf::from(SYSTEM_RUNTIMES_DIR)
+        .join("librune.so")
+        .exists()
 }
 
 impl LoadedRuntime {
     /// Load the Rune runtime from the system directory
-    pub fn load_rune(plugins_dir: &Path) -> PluginResult<Self> {
+    pub fn load_rune(plugins_dir: &Path, owlry_version: &str) -> PluginResult<Self> {
         Self::load_from_path(
             "Rune",
             &PathBuf::from(SYSTEM_RUNTIMES_DIR).join("librune.so"),
             b"owlry_rune_runtime_vtable",
             plugins_dir,
+            owlry_version,
         )
     }
 }

crates/owlry-core/src/plugins/watcher.rs

@@ -0,0 +1,104 @@
+//! Filesystem watcher for user plugin hot-reload
+//!
+//! Watches `~/.config/owlry/plugins/` for changes and triggers
+//! runtime reload when plugin files are modified.
+
+use std::path::PathBuf;
+use std::sync::{Arc, RwLock};
+use std::thread;
+use std::time::Duration;
+
+use log::{info, warn};
+use notify_debouncer_mini::{new_debouncer, DebouncedEventKind};
+
+use crate::providers::ProviderManager;
+
+/// Start watching the user plugins directory for changes.
+///
+/// Spawns a background thread that monitors the directory and triggers
+/// a full runtime reload on any file change. Returns immediately.
+///
+/// Respects `OWLRY_SKIP_RUNTIMES=1` — returns early if set.
+pub fn start_watching(pm: Arc<RwLock<ProviderManager>>) {
+    if std::env::var("OWLRY_SKIP_RUNTIMES").is_ok() {
+        info!("OWLRY_SKIP_RUNTIMES set, skipping file watcher");
+        return;
+    }
+
+    let plugins_dir = match crate::paths::plugins_dir() {
+        Some(d) => d,
+        None => {
+            info!("No plugins directory configured, skipping file watcher");
+            return;
+        }
+    };
+
+    if !plugins_dir.exists()
+        && std::fs::create_dir_all(&plugins_dir).is_err()
+    {
+        warn!(
+            "Failed to create plugins directory: {}",
+            plugins_dir.display()
+        );
+        return;
+    }
+
+    info!(
+        "Plugin file watcher started for {}",
+        plugins_dir.display()
+    );
+
+    thread::spawn(move || {
+        if let Err(e) = watch_loop(&plugins_dir, &pm) {
+            warn!("Plugin watcher stopped: {}", e);
+        }
+    });
+}
+
+fn watch_loop(
+    plugins_dir: &PathBuf,
+    pm: &Arc<RwLock<ProviderManager>>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let (tx, rx) = std::sync::mpsc::channel();
+
+    let mut debouncer = new_debouncer(Duration::from_millis(500), tx)?;
+
+    debouncer
+        .watcher()
+        .watch(plugins_dir.as_ref(), notify::RecursiveMode::Recursive)?;
+
+    info!("Watching {} for plugin changes", plugins_dir.display());
+
+    // Skip events during initial startup grace period (watcher setup triggers events)
+    let startup = std::time::Instant::now();
+    let grace_period = Duration::from_secs(2);
+
+    loop {
+        match rx.recv() {
+            Ok(Ok(events)) => {
+                if startup.elapsed() < grace_period {
+                    continue;
+                }
+
+                let has_relevant_change = events.iter().any(|e| {
+                    matches!(
+                        e.kind,
+                        DebouncedEventKind::Any | DebouncedEventKind::AnyContinuous
+                    )
+                });
+
+                if has_relevant_change {
+                    info!("Plugin file change detected, reloading runtimes...");
+                    let mut pm_guard = pm.write().unwrap_or_else(|e| e.into_inner());
+                    pm_guard.reload_runtimes();
+                }
+            }
+            Ok(Err(error)) => {
+                warn!("File watcher error: {}", error);
+            }
+            Err(e) => {
+                return Err(Box::new(e));
+            }
+        }
+    }
+}

crates/owlry-core/src/providers/application.rs

@@ -66,13 +66,14 @@ fn clean_desktop_exec_field(cmd: &str) -> String {
     cleaned
 }
 
+#[derive(Default)]
 pub struct ApplicationProvider {
     items: Vec<LaunchItem>,
 }
 
 impl ApplicationProvider {
     pub fn new() -> Self {
-        Self { items: Vec::new() }
+        Self::default()
     }
 
     fn get_application_dirs() -> Vec<std::path::PathBuf> {
@@ -139,15 +140,18 @@ impl Provider for ApplicationProvider {
             if !current_desktops.is_empty() {
                 // OnlyShowIn: if set, current desktop must be in the list
                 if desktop_entry.only_show_in().is_some_and(|only| {
-                    !current_desktops.iter().any(|de| only.contains(&de.as_str()))
+                    !current_desktops
+                        .iter()
+                        .any(|de| only.contains(&de.as_str()))
                 }) {
                     continue;
                 }
 
                 // NotShowIn: if current desktop is in the list, skip
-                if desktop_entry.not_show_in().is_some_and(|not| {
-                    current_desktops.iter().any(|de| not.contains(&de.as_str()))
-                }) {
+                if desktop_entry
+                    .not_show_in()
+                    .is_some_and(|not| current_desktops.iter().any(|de| not.contains(&de.as_str())))
+                {
                     continue;
                 }
             }
@@ -197,7 +201,8 @@ impl Provider for ApplicationProvider {
         );
 
         // Sort alphabetically by name
-        self.items.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+        self.items
+            .sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
     }
 
     fn items(&self) -> &[LaunchItem] {
@@ -219,7 +224,10 @@ mod tests {
     #[test]
     fn test_clean_desktop_exec_multiple_placeholders() {
         assert_eq!(clean_desktop_exec_field("app %f %u %U"), "app");
-        assert_eq!(clean_desktop_exec_field("app --flag %u --other"), "app --flag --other");
+        assert_eq!(
+            clean_desktop_exec_field("app --flag %u --other"),
+            "app --flag --other"
+        );
     }
 
     #[test]

crates/owlry-core/src/providers/calculator.rs

@@ -0,0 +1,237 @@
+use super::{DynamicProvider, LaunchItem, ProviderType};
+
+/// Built-in calculator provider. Evaluates mathematical expressions via `meval`.
+///
+/// Triggered by:
+/// - `= expr` / `=expr` / `calc expr` (explicit prefix)
+/// - Raw math expressions containing operators or known functions (auto-detect)
+pub(crate) struct CalculatorProvider;
+
+impl DynamicProvider for CalculatorProvider {
+    fn name(&self) -> &str {
+        "Calculator"
+    }
+
+    fn provider_type(&self) -> ProviderType {
+        ProviderType::Plugin("calc".into())
+    }
+
+    fn priority(&self) -> u32 {
+        10_000
+    }
+
+    fn query(&self, query: &str) -> Vec<LaunchItem> {
+        let expr = match extract_expression(query) {
+            Some(e) if !e.is_empty() => e,
+            _ => return Vec::new(),
+        };
+
+        match meval::eval_str(expr) {
+            Ok(result) => {
+                let display = format_result(result);
+                let copy_cmd = format!(
+                    "printf '%s' '{}' | wl-copy",
+                    display.replace('\'', "'\\''")
+                );
+                vec![LaunchItem {
+                    id: format!("calc:{}", expr),
+                    name: display.clone(),
+                    description: Some(format!("= {}", expr)),
+                    icon: Some("accessories-calculator".into()),
+                    provider: ProviderType::Plugin("calc".into()),
+                    command: copy_cmd,
+                    terminal: false,
+                    tags: vec!["math".into(), "calculator".into()],
+                }]
+            }
+            Err(_) => Vec::new(),
+        }
+    }
+}
+
+/// Extract the math expression from a query string.
+///
+/// Handles:
+/// - `= expr` and `=expr` (explicit calculator prefix)
+/// - `calc expr` (word prefix)
+/// - Raw expressions if they look like math (auto-detect)
+///
+/// Returns `None` only when input is empty after trimming.
+fn extract_expression(query: &str) -> Option<&str> {
+    let trimmed = query.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    // Explicit prefixes
+    if let Some(rest) = trimmed.strip_prefix("= ") {
+        return Some(rest.trim());
+    }
+    if let Some(rest) = trimmed.strip_prefix('=') {
+        return Some(rest.trim());
+    }
+    if let Some(rest) = trimmed.strip_prefix("calc ") {
+        return Some(rest.trim());
+    }
+
+    // Auto-detect: only forward if the expression looks like math.
+    // Plain words like "firefox" should not reach meval.
+    if looks_like_math(trimmed) {
+        Some(trimmed)
+    } else {
+        None
+    }
+}
+
+/// Heuristic: does this string look like a math expression?
+///
+/// Returns true when the string contains binary operators, digits mixed with
+/// operators, or known function names. Plain alphabetic words return false.
+fn looks_like_math(s: &str) -> bool {
+    // Must contain at least one digit or a known constant/function name
+    let has_digit = s.chars().any(|c| c.is_ascii_digit());
+    let has_operator = s.contains('+')
+        || s.contains('*')
+        || s.contains('/')
+        || s.contains('^')
+        || s.contains('%');
+    // Subtraction/negation is ambiguous; only count it as an operator when
+    // there are already digits present to avoid matching bare words with hyphens.
+    let has_minus_operator = has_digit && s.contains('-');
+
+    // Known math functions that are safe to auto-evaluate
+    const MATH_FUNCTIONS: &[&str] = &[
+        "sqrt", "sin", "cos", "tan", "log", "ln", "abs", "floor", "ceil", "round",
+    ];
+    let has_function = MATH_FUNCTIONS.iter().any(|f| s.contains(f));
+
+    has_digit && (has_operator || has_minus_operator) || has_function
+}
+
+/// Format a floating-point result for display.
+///
+/// Integer-valued results are shown as integers with thousands separators.
+/// Non-integer results are shown with up to 10 decimal places, trailing zeros trimmed.
+fn format_result(result: f64) -> String {
+    if result.fract() == 0.0 && result.abs() < 1e15 {
+        format_integer_with_separators(result as i64)
+    } else {
+        let formatted = format!("{:.10}", result);
+        formatted
+            .trim_end_matches('0')
+            .trim_end_matches('.')
+            .to_string()
+    }
+}
+
+fn format_integer_with_separators(n: i64) -> String {
+    let s = n.unsigned_abs().to_string();
+    let with_commas = s
+        .as_bytes()
+        .rchunks(3)
+        .rev()
+        .map(|chunk| std::str::from_utf8(chunk).unwrap())
+        .collect::<Vec<_>>()
+        .join(",");
+
+    if n < 0 {
+        format!("-{}", with_commas)
+    } else {
+        with_commas
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn query(q: &str) -> Vec<LaunchItem> {
+        CalculatorProvider.query(q)
+    }
+
+    // --- Trigger prefix tests ---
+
+    #[test]
+    fn equals_prefix_addition() {
+        let results = query("= 5+3");
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].name, "8");
+    }
+
+    #[test]
+    fn calc_prefix_multiplication() {
+        let results = query("calc 10*2");
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].name, "20");
+    }
+
+    // --- Auto-detect tests ---
+
+    #[test]
+    fn auto_detect_addition() {
+        let results = query("5+3");
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].name, "8");
+    }
+
+    #[test]
+    fn equals_prefix_complex_expression() {
+        let results = query("= sqrt(16) + 2^3");
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].name, "12");
+    }
+
+    #[test]
+    fn decimal_result() {
+        let results = query("= 10/3");
+        assert_eq!(results.len(), 1);
+        assert!(
+            results[0].name.starts_with("3.333"),
+            "expected result starting with 3.333, got: {}",
+            results[0].name
+        );
+    }
+
+    #[test]
+    fn large_integer_thousands_separators() {
+        let results = query("= 1000000");
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].name, "1,000,000");
+    }
+
+    // --- Invalid / non-math input ---
+
+    #[test]
+    fn invalid_expression_returns_empty() {
+        let results = query("= 5 +");
+        assert!(results.is_empty());
+    }
+
+    #[test]
+    fn plain_text_returns_empty() {
+        let results = query("firefox");
+        assert!(results.is_empty());
+    }
+
+    // --- Metadata tests ---
+
+    #[test]
+    fn provider_type_is_calc_plugin() {
+        assert_eq!(
+            CalculatorProvider.provider_type(),
+            ProviderType::Plugin("calc".into())
+        );
+    }
+
+    #[test]
+    fn description_shows_expression() {
+        let results = query("= 5+3");
+        assert_eq!(results[0].description.as_deref(), Some("= 5+3"));
+    }
+
+    #[test]
+    fn copy_command_contains_wl_copy() {
+        let results = query("= 5+3");
+        assert!(results[0].command.contains("wl-copy"));
+    }
+}

crates/owlry-core/src/providers/command.rs

@@ -4,13 +4,14 @@ use std::collections::HashSet;
 use std::os::unix::fs::PermissionsExt;
 use std::path::PathBuf;
 
+#[derive(Default)]
 pub struct CommandProvider {
     items: Vec<LaunchItem>,
 }
 
 impl CommandProvider {
     pub fn new() -> Self {
-        Self { items: Vec::new() }
+        Self::default()
     }
 
     fn get_path_dirs() -> Vec<PathBuf> {
@@ -97,7 +98,8 @@ impl Provider for CommandProvider {
         debug!("Found {} commands in PATH", self.items.len());
 
         // Sort alphabetically
-        self.items.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+        self.items
+            .sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
     }
 
     fn items(&self) -> &[LaunchItem] {

crates/owlry-core/src/providers/converter/currency.rs

@@ -0,0 +1,313 @@
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Mutex;
+use std::time::SystemTime;
+
+use serde::{Deserialize, Serialize};
+
+const ECB_URL: &str = "https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml";
+const CACHE_MAX_AGE_SECS: u64 = 86400; // 24 hours
+
+static CACHED_RATES: Mutex<Option<CurrencyRates>> = Mutex::new(None);
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CurrencyRates {
+    pub date: String,
+    pub rates: HashMap<String, f64>,
+}
+
+struct CurrencyAlias {
+    code: &'static str,
+    aliases: &'static [&'static str],
+}
+
+static CURRENCY_ALIASES: &[CurrencyAlias] = &[
+    CurrencyAlias {
+        code: "EUR",
+        aliases: &["eur", "euro", "euros", "€"],
+    },
+    CurrencyAlias {
+        code: "USD",
+        aliases: &["usd", "dollar", "dollars", "$", "us_dollar"],
+    },
+    CurrencyAlias {
+        code: "GBP",
+        aliases: &["gbp", "pound_sterling", "£", "british_pound", "pounds"],
+    },
+    CurrencyAlias {
+        code: "JPY",
+        aliases: &["jpy", "yen", "¥", "japanese_yen"],
+    },
+    CurrencyAlias {
+        code: "CHF",
+        aliases: &["chf", "swiss_franc", "francs"],
+    },
+    CurrencyAlias {
+        code: "CAD",
+        aliases: &["cad", "canadian_dollar", "c$"],
+    },
+    CurrencyAlias {
+        code: "AUD",
+        aliases: &["aud", "australian_dollar", "a$"],
+    },
+    CurrencyAlias {
+        code: "CNY",
+        aliases: &["cny", "yuan", "renminbi", "rmb"],
+    },
+    CurrencyAlias {
+        code: "SEK",
+        aliases: &["sek", "swedish_krona", "kronor"],
+    },
+    CurrencyAlias {
+        code: "NOK",
+        aliases: &["nok", "norwegian_krone"],
+    },
+    CurrencyAlias {
+        code: "DKK",
+        aliases: &["dkk", "danish_krone"],
+    },
+    CurrencyAlias {
+        code: "PLN",
+        aliases: &["pln", "zloty", "złoty"],
+    },
+    CurrencyAlias {
+        code: "CZK",
+        aliases: &["czk", "czech_koruna"],
+    },
+    CurrencyAlias {
+        code: "HUF",
+        aliases: &["huf", "forint"],
+    },
+    CurrencyAlias {
+        code: "TRY",
+        aliases: &["try", "turkish_lira", "lira"],
+    },
+];
+
+pub fn resolve_currency_code(alias: &str) -> Option<&'static str> {
+    let lower = alias.to_lowercase();
+
+    // Check aliases
+    for ca in CURRENCY_ALIASES {
+        if ca.aliases.contains(&lower.as_str()) {
+            return Some(ca.code); // ca.code is already &'static str
+        }
+    }
+
+    // Check if it's a raw 3-letter ISO code we know about
+    let upper = alias.to_uppercase();
+    if upper.len() == 3 {
+        if upper == "EUR" {
+            return Some("EUR");
+        }
+        if let Some(rates) = get_rates()
+            && rates.rates.contains_key(&upper)
+        {
+            for ca in CURRENCY_ALIASES {
+                if ca.code == upper {
+                    return Some(ca.code);
+                }
+            }
+        }
+    }
+
+    None
+}
+
+#[allow(dead_code)]
+pub fn is_currency_alias(alias: &str) -> bool {
+    resolve_currency_code(alias).is_some()
+}
+
+pub fn get_rates() -> Option<CurrencyRates> {
+    // Check memory cache first
+    {
+        let cache = CACHED_RATES.lock().ok()?;
+        if let Some(ref rates) = *cache {
+            return Some(rates.clone());
+        }
+    }
+
+    // Try disk cache
+    if let Some(rates) = load_cache()
+        && !is_stale(&rates)
+    {
+        let mut cache = CACHED_RATES.lock().ok()?;
+        *cache = Some(rates.clone());
+        return Some(rates);
+    }
+
+    // Fetch fresh rates
+    if let Some(rates) = fetch_rates() {
+        save_cache(&rates);
+        let mut cache = CACHED_RATES.lock().ok()?;
+        *cache = Some(rates.clone());
+        return Some(rates);
+    }
+
+    // Fall back to stale cache
+    load_cache()
+}
+
+fn cache_path() -> Option<PathBuf> {
+    let cache_dir = dirs::cache_dir()?.join("owlry");
+    Some(cache_dir.join("ecb_rates.json"))
+}
+
+fn load_cache() -> Option<CurrencyRates> {
+    let path = cache_path()?;
+    let content = fs::read_to_string(path).ok()?;
+    serde_json::from_str(&content).ok()
+}
+
+fn save_cache(rates: &CurrencyRates) {
+    if let Some(path) = cache_path() {
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).ok();
+        }
+        if let Ok(json) = serde_json::to_string_pretty(rates) {
+            fs::write(path, json).ok();
+        }
+    }
+}
+
+fn is_stale(_rates: &CurrencyRates) -> bool {
+    let path = match cache_path() {
+        Some(p) => p,
+        None => return true,
+    };
+    let metadata = match fs::metadata(path) {
+        Ok(m) => m,
+        Err(_) => return true,
+    };
+    let modified = match metadata.modified() {
+        Ok(t) => t,
+        Err(_) => return true,
+    };
+    match SystemTime::now().duration_since(modified) {
+        Ok(age) => age.as_secs() > CACHE_MAX_AGE_SECS,
+        Err(_) => true,
+    }
+}
+
+fn fetch_rates() -> Option<CurrencyRates> {
+    let response = reqwest::blocking::get(ECB_URL).ok()?;
+    let body = response.text().ok()?;
+    parse_ecb_xml(&body)
+}
+
+fn parse_ecb_xml(xml: &str) -> Option<CurrencyRates> {
+    let mut rates = HashMap::new();
+    let mut date = String::new();
+
+    for line in xml.lines() {
+        let trimmed = line.trim();
+
+        // Extract date: <Cube time='2026-03-26'>
+        if trimmed.contains("time=")
+            && let Some(start) = trimmed.find("time='")
+        {
+            let rest = &trimmed[start + 6..];
+            if let Some(end) = rest.find('\'') {
+                date = rest[..end].to_string();
+            }
+        }
+
+        // Extract rate: <Cube currency='USD' rate='1.0832'/>
+        if trimmed.contains("currency=") && trimmed.contains("rate=") {
+            let currency = extract_attr(trimmed, "currency")?;
+            let rate_str = extract_attr(trimmed, "rate")?;
+            let rate: f64 = rate_str.parse().ok()?;
+            rates.insert(currency, rate);
+        }
+    }
+
+    if rates.is_empty() {
+        return None;
+    }
+
+    Some(CurrencyRates { date, rates })
+}
+
+fn extract_attr(line: &str, attr: &str) -> Option<String> {
+    let needle = format!("{}='", attr);
+    let start = line.find(&needle)? + needle.len();
+    let rest = &line[start..];
+    let end = rest.find('\'')?;
+    Some(rest[..end].to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_resolve_currency_code_iso() {
+        assert_eq!(resolve_currency_code("usd"), Some("USD"));
+        assert_eq!(resolve_currency_code("EUR"), Some("EUR"));
+    }
+
+    #[test]
+    fn test_resolve_currency_code_name() {
+        assert_eq!(resolve_currency_code("dollar"), Some("USD"));
+        assert_eq!(resolve_currency_code("euro"), Some("EUR"));
+        assert_eq!(resolve_currency_code("pounds"), Some("GBP"));
+    }
+
+    #[test]
+    fn test_resolve_currency_code_symbol() {
+        assert_eq!(resolve_currency_code("$"), Some("USD"));
+        assert_eq!(resolve_currency_code("€"), Some("EUR"));
+        assert_eq!(resolve_currency_code("£"), Some("GBP"));
+    }
+
+    #[test]
+    fn test_resolve_currency_unknown() {
+        assert_eq!(resolve_currency_code("xyz"), None);
+    }
+
+    #[test]
+    fn test_is_currency_alias() {
+        assert!(is_currency_alias("usd"));
+        assert!(is_currency_alias("euro"));
+        assert!(is_currency_alias("$"));
+        assert!(!is_currency_alias("km"));
+    }
+
+    #[test]
+    fn test_parse_ecb_xml() {
+        let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
+<gesmes:Envelope xmlns:gesmes="http://www.gesmes.org/xml/2002-08-01" xmlns="http://www.ecb.int/vocabulary/2002-08-01/eurofxref">
+    <gesmes:subject>Reference rates</gesmes:subject>
+    <Cube>
+        <Cube time='2026-03-26'>
+            <Cube currency='USD' rate='1.0832'/>
+            <Cube currency='JPY' rate='161.94'/>
+            <Cube currency='GBP' rate='0.83450'/>
+        </Cube>
+    </Cube>
+</gesmes:Envelope>"#;
+
+        let rates = parse_ecb_xml(xml).unwrap();
+        assert!((rates.rates["USD"] - 1.0832).abs() < 0.001);
+        assert!((rates.rates["GBP"] - 0.8345).abs() < 0.001);
+        assert!((rates.rates["JPY"] - 161.94).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_cache_roundtrip() {
+        let rates = CurrencyRates {
+            date: "2026-03-26".to_string(),
+            rates: {
+                let mut m = HashMap::new();
+                m.insert("USD".to_string(), 1.0832);
+                m.insert("GBP".to_string(), 0.8345);
+                m
+            },
+        };
+        let json = serde_json::to_string(&rates).unwrap();
+        let parsed: CurrencyRates = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.rates["USD"], 1.0832);
+    }
+}

crates/owlry-core/src/providers/converter/mod.rs

@@ -0,0 +1,183 @@
+mod currency;
+mod parser;
+mod units;
+
+use super::{DynamicProvider, LaunchItem, ProviderType};
+
+const PROVIDER_TYPE_ID: &str = "conv";
+const PROVIDER_ICON: &str = "edit-find-replace-symbolic";
+
+pub struct ConverterProvider;
+
+impl ConverterProvider {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl DynamicProvider for ConverterProvider {
+    fn name(&self) -> &str {
+        "Converter"
+    }
+
+    fn provider_type(&self) -> ProviderType {
+        ProviderType::Plugin(PROVIDER_TYPE_ID.into())
+    }
+
+    fn priority(&self) -> u32 {
+        9_000
+    }
+
+    fn query(&self, query: &str) -> Vec<LaunchItem> {
+        let query_str = query.trim();
+        // Strip prefix
+        let input = if let Some(rest) = query_str.strip_prefix('>') {
+            rest.trim()
+        } else {
+            query_str
+        };
+
+        let parsed = match parser::parse_conversion(input) {
+            Some(p) => p,
+            None => return Vec::new(),
+        };
+
+        let results = if let Some(ref target) = parsed.target_unit {
+            units::convert_to(&parsed.value, &parsed.from_unit, target)
+                .into_iter()
+                .collect()
+        } else {
+            units::convert_common(&parsed.value, &parsed.from_unit)
+        };
+
+        results
+            .into_iter()
+            .map(|r| LaunchItem {
+                id: format!("conv:{}:{}:{}", parsed.from_unit, r.target_symbol, r.value),
+                name: r.display_value.clone(),
+                description: Some(format!(
+                    "{} {} = {}",
+                    format_number(parsed.value),
+                    parsed.from_symbol,
+                    r.display_value,
+                )),
+                icon: Some(PROVIDER_ICON.into()),
+                provider: ProviderType::Plugin(PROVIDER_TYPE_ID.into()),
+                command: format!(
+                    "printf '%s' '{}' | wl-copy",
+                    r.raw_value.replace('\'', "'\\''")
+                ),
+                terminal: false,
+                tags: vec!["converter".into(), "units".into()],
+            })
+            .collect()
+    }
+}
+
+fn format_number(n: f64) -> String {
+    if n.fract() == 0.0 && n.abs() < 1e15 {
+        let i = n as i64;
+        if i.abs() >= 1000 {
+            format_with_separators(i)
+        } else {
+            format!("{}", i)
+        }
+    } else {
+        format!("{:.4}", n)
+            .trim_end_matches('0')
+            .trim_end_matches('.')
+            .to_string()
+    }
+}
+
+pub(crate) fn format_with_separators(n: i64) -> String {
+    let s = n.abs().to_string();
+    let mut result = String::new();
+    for (i, c) in s.chars().rev().enumerate() {
+        if i > 0 && i % 3 == 0 {
+            result.push(',');
+        }
+        result.push(c);
+    }
+    if n < 0 {
+        result.push('-');
+    }
+    result.chars().rev().collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn query(input: &str) -> Vec<LaunchItem> {
+        ConverterProvider::new().query(input)
+    }
+
+    #[test]
+    fn test_prefix_trigger() {
+        let r = query("> 100 km to mi");
+        assert!(!r.is_empty());
+    }
+
+    #[test]
+    fn test_auto_detect() {
+        let r = query("100 km to mi");
+        assert!(!r.is_empty());
+    }
+
+    #[test]
+    fn test_common_conversions() {
+        let r = query("> 100 km");
+        assert!(r.len() > 1);
+    }
+
+    #[test]
+    fn test_temperature() {
+        let r = query("102F to C");
+        assert!(!r.is_empty());
+    }
+
+    #[test]
+    fn test_nonsense_returns_empty() {
+        assert!(query("hello world").is_empty());
+    }
+
+    #[test]
+    fn test_provider_type() {
+        assert_eq!(
+            ConverterProvider::new().provider_type(),
+            ProviderType::Plugin("conv".into())
+        );
+    }
+
+    #[test]
+    fn test_no_double_unit() {
+        let r = query("100 km to mi");
+        if let Some(item) = r.first() {
+            let desc = item.description.as_deref().unwrap();
+            assert!(!desc.ends_with(" mi mi"), "double unit in: {}", desc);
+        }
+    }
+
+    #[test]
+    fn test_format_number_integer() {
+        assert_eq!(format_number(42.0), "42");
+    }
+
+    #[test]
+    fn test_format_number_large_integer() {
+        assert_eq!(format_number(1000000.0), "1,000,000");
+    }
+
+    #[test]
+    fn test_format_number_decimal() {
+        assert_eq!(format_number(3.14), "3.14");
+    }
+
+    #[test]
+    fn test_format_with_separators() {
+        assert_eq!(format_with_separators(1234567), "1,234,567");
+        assert_eq!(format_with_separators(999), "999");
+        assert_eq!(format_with_separators(-1234), "-1,234");
+    }
+}

crates/owlry-core/src/providers/converter/parser.rs

@@ -0,0 +1,235 @@
+use super::units;
+
+pub struct ParsedQuery {
+    pub value: f64,
+    pub from_unit: String,
+    pub from_symbol: String,
+    pub target_unit: Option<String>,
+}
+
+pub fn parse_conversion(input: &str) -> Option<ParsedQuery> {
+    let input = input.trim();
+    if input.is_empty() {
+        return None;
+    }
+
+    // Extract leading number
+    let (value, rest) = extract_number(input)?;
+    let rest = rest.trim();
+
+    if rest.is_empty() {
+        return None;
+    }
+
+    // Split on " to " or " in " (case-insensitive)
+    let (from_str, target_str) = split_on_connector(rest);
+
+    // Resolve from unit
+    let from_lower = from_str.trim().to_lowercase();
+    let from_symbol = units::find_unit(&from_lower)?;
+
+    let from_symbol_str = from_symbol.to_string();
+
+    // Resolve target unit if present
+    let target_unit = target_str.and_then(|t| {
+        let t_lower = t.trim().to_lowercase();
+        if t_lower.is_empty() {
+            None
+        } else {
+            units::find_unit(&t_lower).map(|_| t_lower)
+        }
+    });
+
+    Some(ParsedQuery {
+        value,
+        from_unit: from_lower,
+        from_symbol: from_symbol_str,
+        target_unit,
+    })
+}
+
+fn extract_number(input: &str) -> Option<(f64, &str)> {
+    let bytes = input.as_bytes();
+    let mut i = 0;
+
+    // Optional negative sign
+    if i < bytes.len() && bytes[i] == b'-' {
+        i += 1;
+    }
+
+    // Must have at least one digit or start with .
+    if i >= bytes.len() {
+        return None;
+    }
+
+    let start_digits = i;
+
+    // Integer part
+    while i < bytes.len() && bytes[i].is_ascii_digit() {
+        i += 1;
+    }
+
+    // Decimal part
+    if i < bytes.len() && bytes[i] == b'.' {
+        i += 1;
+        while i < bytes.len() && bytes[i].is_ascii_digit() {
+            i += 1;
+        }
+    }
+
+    if i == start_digits && !(i > 0 && bytes[0] == b'-') {
+        // No digits found (and not just a negative sign before a dot)
+        // Handle ".5" case
+        if bytes[start_digits] == b'.' {
+            // already advanced past dot above
+        } else {
+            return None;
+        }
+    }
+
+    if i == 0 || (i == 1 && bytes[0] == b'-') {
+        return None;
+    }
+
+    let num_str = &input[..i];
+    let value: f64 = num_str.parse().ok()?;
+    let rest = &input[i..];
+
+    Some((value, rest))
+}
+
+fn split_on_connector(input: &str) -> (&str, Option<&str>) {
+    let lower = input.to_lowercase();
+
+    // Try " to " first
+    if let Some(pos) = lower.find(" to ") {
+        let from = &input[..pos];
+        let target = &input[pos + 4..];
+        return (from, Some(target));
+    }
+
+    // Try " in "
+    if let Some(pos) = lower.find(" in ") {
+        let from = &input[..pos];
+        let target = &input[pos + 4..];
+        return (from, Some(target));
+    }
+
+    (input, None)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_number_and_unit_with_space() {
+        let p = parse_conversion("100 km").unwrap();
+        assert!((p.value - 100.0).abs() < 0.001);
+        assert_eq!(p.from_unit, "km");
+        assert!(p.target_unit.is_none());
+    }
+
+    #[test]
+    fn test_number_and_unit_no_space() {
+        let p = parse_conversion("100km").unwrap();
+        assert!((p.value - 100.0).abs() < 0.001);
+        assert_eq!(p.from_unit, "km");
+    }
+
+    #[test]
+    fn test_with_target_to() {
+        let p = parse_conversion("100 km to mi").unwrap();
+        assert!((p.value - 100.0).abs() < 0.001);
+        assert_eq!(p.from_unit, "km");
+        assert_eq!(p.target_unit.as_deref(), Some("mi"));
+    }
+
+    #[test]
+    fn test_with_target_in() {
+        let p = parse_conversion("100 km in mi").unwrap();
+        assert_eq!(p.target_unit.as_deref(), Some("mi"));
+    }
+
+    #[test]
+    fn test_temperature_no_space() {
+        let p = parse_conversion("102F to C").unwrap();
+        assert!((p.value - 102.0).abs() < 0.001);
+        assert_eq!(p.from_unit, "f");
+        assert_eq!(p.target_unit.as_deref(), Some("c"));
+    }
+
+    #[test]
+    fn test_temperature_with_space() {
+        let p = parse_conversion("102 F in K").unwrap();
+        assert!((p.value - 102.0).abs() < 0.001);
+        assert_eq!(p.from_unit, "f");
+        assert_eq!(p.target_unit.as_deref(), Some("k"));
+    }
+
+    #[test]
+    fn test_decimal_number() {
+        let p = parse_conversion("3.5 kg to lb").unwrap();
+        assert!((p.value - 3.5).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_decimal_starting_with_dot() {
+        let p = parse_conversion(".5 kg").unwrap();
+        assert!((p.value - 0.5).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_full_unit_names() {
+        let p = parse_conversion("100 kilometers to miles").unwrap();
+        assert_eq!(p.from_unit, "kilometers");
+        assert_eq!(p.target_unit.as_deref(), Some("miles"));
+    }
+
+    #[test]
+    fn test_case_insensitive() {
+        let p = parse_conversion("100 KM TO MI").unwrap();
+        assert_eq!(p.from_unit, "km");
+        assert_eq!(p.target_unit.as_deref(), Some("mi"));
+    }
+
+    #[test]
+    fn test_currency() {
+        let p = parse_conversion("100 eur to usd").unwrap();
+        assert_eq!(p.from_unit, "eur");
+        assert_eq!(p.target_unit.as_deref(), Some("usd"));
+    }
+
+    #[test]
+    fn test_no_number_returns_none() {
+        assert!(parse_conversion("km to mi").is_none());
+    }
+
+    #[test]
+    fn test_unknown_unit_returns_none() {
+        assert!(parse_conversion("100 xyz to abc").is_none());
+    }
+
+    #[test]
+    fn test_empty_returns_none() {
+        assert!(parse_conversion("").is_none());
+    }
+
+    #[test]
+    fn test_number_only_returns_none() {
+        assert!(parse_conversion("100").is_none());
+    }
+
+    #[test]
+    fn test_compound_unit_alias() {
+        let p = parse_conversion("100 km/h to mph").unwrap();
+        assert_eq!(p.from_unit, "km/h");
+        assert_eq!(p.target_unit.as_deref(), Some("mph"));
+    }
+
+    #[test]
+    fn test_multi_word_unit() {
+        let p = parse_conversion("100 fl_oz to ml").unwrap();
+        assert_eq!(p.from_unit, "fl_oz");
+    }
+}

crates/owlry-core/src/providers/converter/units.rs

@@ -0,0 +1,944 @@
+use std::collections::HashMap;
+use std::sync::LazyLock;
+
+use super::currency;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Category {
+    Temperature,
+    Length,
+    Weight,
+    Volume,
+    Speed,
+    Area,
+    Data,
+    Time,
+    Pressure,
+    Energy,
+    Currency,
+}
+
+#[derive(Clone)]
+enum Conversion {
+    Factor(f64),
+    Custom {
+        to_base: fn(f64) -> f64,
+        from_base: fn(f64) -> f64,
+    },
+}
+
+#[derive(Clone)]
+pub(crate) struct UnitDef {
+    _id: &'static str,
+    symbol: &'static str,
+    aliases: &'static [&'static str],
+    category: Category,
+    conversion: Conversion,
+}
+
+impl UnitDef {
+    fn to_base(&self, value: f64) -> f64 {
+        match &self.conversion {
+            Conversion::Factor(f) => value * f,
+            Conversion::Custom { to_base, .. } => to_base(value),
+        }
+    }
+
+    fn convert_from_base(&self, value: f64) -> f64 {
+        match &self.conversion {
+            Conversion::Factor(f) => value / f,
+            Conversion::Custom { from_base, .. } => from_base(value),
+        }
+    }
+}
+
+pub struct ConversionResult {
+    pub value: f64,
+    pub raw_value: String,
+    pub display_value: String,
+    pub target_symbol: String,
+}
+
+static UNITS: LazyLock<Vec<UnitDef>> = LazyLock::new(build_unit_table);
+static ALIAS_MAP: LazyLock<HashMap<String, usize>> = LazyLock::new(|| {
+    let mut map = HashMap::new();
+    for (i, unit) in UNITS.iter().enumerate() {
+        for alias in unit.aliases {
+            map.insert(alias.to_lowercase(), i);
+        }
+    }
+    map
+});
+
+// Common conversions per category (symbols to show when no target specified)
+static COMMON_TARGETS: LazyLock<HashMap<Category, Vec<&'static str>>> = LazyLock::new(|| {
+    let mut m = HashMap::new();
+    m.insert(Category::Temperature, vec!["°C", "°F", "K"]);
+    m.insert(Category::Length, vec!["m", "km", "ft", "mi", "in"]);
+    m.insert(Category::Weight, vec!["kg", "lb", "oz", "g", "st"]);
+    m.insert(Category::Volume, vec!["l", "gal", "ml", "cup", "fl oz"]);
+    m.insert(Category::Speed, vec!["km/h", "mph", "m/s", "kn"]);
+    m.insert(Category::Area, vec!["m²", "ft²", "ac", "ha", "km²"]);
+    m.insert(Category::Data, vec!["MB", "GB", "MiB", "GiB", "TB"]);
+    m.insert(Category::Time, vec!["s", "min", "h", "d", "wk"]);
+    m.insert(Category::Pressure, vec!["bar", "psi", "atm", "hPa", "mmHg"]);
+    m.insert(Category::Energy, vec!["kJ", "kcal", "kWh", "BTU", "Wh"]);
+    m.insert(Category::Currency, vec!["USD", "EUR", "GBP", "JPY", "CNY"]);
+    m
+});
+
+pub fn find_unit(alias: &str) -> Option<&'static str> {
+    let lower = alias.to_lowercase();
+    if let Some(&i) = ALIAS_MAP.get(&lower) {
+        return Some(UNITS[i].symbol);
+    }
+    currency::resolve_currency_code(&lower)
+}
+
+pub fn lookup_unit(alias: &str) -> Option<(usize, &UnitDef)> {
+    let lower = alias.to_lowercase();
+    ALIAS_MAP.get(&lower).map(|&i| (i, &UNITS[i]))
+}
+
+pub fn convert_to(value: &f64, from: &str, to: &str) -> Option<ConversionResult> {
+    // Try currency first — currency aliases (dollar, euro, etc.) aren't in the UNITS table
+    if currency::is_currency_alias(from) || currency::is_currency_alias(to) {
+        return convert_currency(*value, from, to);
+    }
+
+    let (_, from_def) = lookup_unit(from)?;
+    let (_, to_def) = lookup_unit(to)?;
+
+    // Currency via UNITS table (shouldn't reach here, but just in case)
+    if from_def.category == Category::Currency || to_def.category == Category::Currency {
+        return convert_currency(*value, from, to);
+    }
+
+    // Must be same category
+    if from_def.category != to_def.category {
+        return None;
+    }
+
+    let base_value = from_def.to_base(*value);
+    let result = to_def.convert_from_base(base_value);
+
+    Some(format_result(result, to_def.symbol))
+}
+
+pub fn convert_common(value: &f64, from: &str) -> Vec<ConversionResult> {
+    // Try currency first — currency aliases (dollar, euro, etc.) aren't in the UNITS table
+    if currency::is_currency_alias(from) {
+        return convert_currency_common(*value, from);
+    }
+
+    let (_, from_def) = match lookup_unit(from) {
+        Some(u) => u,
+        None => return vec![],
+    };
+
+    let category = from_def.category;
+    let from_symbol = from_def.symbol;
+
+    if category == Category::Currency {
+        return convert_currency_common(*value, from);
+    }
+
+    let targets = match COMMON_TARGETS.get(&category) {
+        Some(t) => t,
+        None => return vec![],
+    };
+
+    let base_value = from_def.to_base(*value);
+
+    targets
+        .iter()
+        .filter(|&&sym| sym != from_symbol)
+        .filter_map(|&sym| {
+            let (_, to_def) = lookup_unit(sym)?;
+            let result = to_def.convert_from_base(base_value);
+            Some(format_result(result, to_def.symbol))
+        })
+        .take(5)
+        .collect()
+}
+
+fn convert_currency(value: f64, from: &str, to: &str) -> Option<ConversionResult> {
+    let rates = currency::get_rates()?;
+    let from_code = currency::resolve_currency_code(from)?;
+    let to_code = currency::resolve_currency_code(to)?;
+
+    let from_rate = if from_code == "EUR" { 1.0 } else { *rates.rates.get(from_code)? };
+    let to_rate = if to_code == "EUR" { 1.0 } else { *rates.rates.get(to_code)? };
+
+    let result = value / from_rate * to_rate;
+    Some(format_currency_result(result, to_code))
+}
+
+fn convert_currency_common(value: f64, from: &str) -> Vec<ConversionResult> {
+    let rates = match currency::get_rates() {
+        Some(r) => r,
+        None => return vec![],
+    };
+    let from_code = match currency::resolve_currency_code(from) {
+        Some(c) => c,
+        None => return vec![],
+    };
+
+    let targets = COMMON_TARGETS.get(&Category::Currency).unwrap();
+    let from_rate = if from_code == "EUR" {
+        1.0
+    } else {
+        match rates.rates.get(from_code) {
+            Some(&r) => r,
+            None => return vec![],
+        }
+    };
+
+    targets
+        .iter()
+        .filter(|&&sym| sym != from_code)
+        .filter_map(|&sym| {
+            let to_rate = if sym == "EUR" { 1.0 } else { *rates.rates.get(sym)? };
+            let result = value / from_rate * to_rate;
+            Some(format_currency_result(result, sym))
+        })
+        .take(5)
+        .collect()
+}
+
+fn format_result(value: f64, symbol: &str) -> ConversionResult {
+    let raw = if value.fract() == 0.0 && value.abs() < 1e15 {
+        format!("{}", value as i64)
+    } else {
+        format!("{:.4}", value)
+            .trim_end_matches('0')
+            .trim_end_matches('.')
+            .to_string()
+    };
+
+    let display = if value.abs() >= 1000.0 && value.fract() == 0.0 && value.abs() < 1e15 {
+        super::format_with_separators(value as i64)
+    } else {
+        raw.clone()
+    };
+
+    ConversionResult {
+        value,
+        raw_value: raw,
+        display_value: format!("{} {}", display, symbol),
+        target_symbol: symbol.to_string(),
+    }
+}
+
+fn format_currency_result(value: f64, code: &str) -> ConversionResult {
+    let raw = format!("{:.2}", value);
+    let display = raw.clone();
+
+    ConversionResult {
+        value,
+        raw_value: raw,
+        display_value: format!("{} {}", display, code),
+        target_symbol: code.to_string(),
+    }
+}
+
+fn build_unit_table() -> Vec<UnitDef> {
+    vec![
+        // Temperature (base: Kelvin)
+        UnitDef {
+            _id: "celsius",
+            symbol: "°C",
+            aliases: &["c", "°c", "celsius", "degc", "centigrade"],
+            category: Category::Temperature,
+            conversion: Conversion::Custom {
+                to_base: |v| v + 273.15,
+                from_base: |v| v - 273.15,
+            },
+        },
+        UnitDef {
+            _id: "fahrenheit",
+            symbol: "°F",
+            aliases: &["f", "°f", "fahrenheit", "degf"],
+            category: Category::Temperature,
+            conversion: Conversion::Custom {
+                to_base: |v| (v - 32.0) * 5.0 / 9.0 + 273.15,
+                from_base: |v| (v - 273.15) * 9.0 / 5.0 + 32.0,
+            },
+        },
+        UnitDef {
+            _id: "kelvin",
+            symbol: "K",
+            aliases: &["k", "kelvin"],
+            category: Category::Temperature,
+            conversion: Conversion::Factor(1.0), // base
+        },
+        // Length (base: meter)
+        UnitDef {
+            _id: "millimeter",
+            symbol: "mm",
+            aliases: &["mm", "millimeter", "millimeters", "millimetre"],
+            category: Category::Length,
+            conversion: Conversion::Factor(0.001),
+        },
+        UnitDef {
+            _id: "centimeter",
+            symbol: "cm",
+            aliases: &["cm", "centimeter", "centimeters", "centimetre"],
+            category: Category::Length,
+            conversion: Conversion::Factor(0.01),
+        },
+        UnitDef {
+            _id: "meter",
+            symbol: "m",
+            aliases: &["m", "meter", "meters", "metre", "metres"],
+            category: Category::Length,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "kilometer",
+            symbol: "km",
+            aliases: &["km", "kms", "kilometer", "kilometers", "kilometre"],
+            category: Category::Length,
+            conversion: Conversion::Factor(1000.0),
+        },
+        UnitDef {
+            _id: "inch",
+            symbol: "in",
+            aliases: &["in", "inch", "inches"],
+            category: Category::Length,
+            conversion: Conversion::Factor(0.0254),
+        },
+        UnitDef {
+            _id: "foot",
+            symbol: "ft",
+            aliases: &["ft", "foot", "feet"],
+            category: Category::Length,
+            conversion: Conversion::Factor(0.3048),
+        },
+        UnitDef {
+            _id: "yard",
+            symbol: "yd",
+            aliases: &["yd", "yard", "yards"],
+            category: Category::Length,
+            conversion: Conversion::Factor(0.9144),
+        },
+        UnitDef {
+            _id: "mile",
+            symbol: "mi",
+            aliases: &["mi", "mile", "miles"],
+            category: Category::Length,
+            conversion: Conversion::Factor(1609.344),
+        },
+        UnitDef {
+            _id: "nautical_mile",
+            symbol: "nmi",
+            aliases: &["nmi", "nautical_mile", "nautical_miles"],
+            category: Category::Length,
+            conversion: Conversion::Factor(1852.0),
+        },
+        // Weight (base: kg)
+        UnitDef {
+            _id: "milligram",
+            symbol: "mg",
+            aliases: &["mg", "milligram", "milligrams"],
+            category: Category::Weight,
+            conversion: Conversion::Factor(0.000001),
+        },
+        UnitDef {
+            _id: "gram",
+            symbol: "g",
+            aliases: &["g", "gram", "grams"],
+            category: Category::Weight,
+            conversion: Conversion::Factor(0.001),
+        },
+        UnitDef {
+            _id: "kilogram",
+            symbol: "kg",
+            aliases: &["kg", "kilogram", "kilograms", "kilo", "kilos"],
+            category: Category::Weight,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "tonne",
+            symbol: "t",
+            aliases: &["t", "ton", "tons", "tonne", "tonnes", "metric_ton"],
+            category: Category::Weight,
+            conversion: Conversion::Factor(1000.0),
+        },
+        UnitDef {
+            _id: "short_ton",
+            symbol: "short_ton",
+            aliases: &["short_ton", "ton_us"],
+            category: Category::Weight,
+            conversion: Conversion::Factor(907.185),
+        },
+        UnitDef {
+            _id: "ounce",
+            symbol: "oz",
+            aliases: &["oz", "ounce", "ounces"],
+            category: Category::Weight,
+            conversion: Conversion::Factor(0.0283495),
+        },
+        UnitDef {
+            _id: "pound",
+            symbol: "lb",
+            aliases: &["lb", "lbs", "pound", "pounds"],
+            category: Category::Weight,
+            conversion: Conversion::Factor(0.453592),
+        },
+        UnitDef {
+            _id: "stone",
+            symbol: "st",
+            aliases: &["st", "stone", "stones"],
+            category: Category::Weight,
+            conversion: Conversion::Factor(6.35029),
+        },
+        // Volume (base: liter)
+        UnitDef {
+            _id: "milliliter",
+            symbol: "ml",
+            aliases: &["ml", "milliliter", "milliliters", "millilitre"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(0.001),
+        },
+        UnitDef {
+            _id: "liter",
+            symbol: "l",
+            aliases: &["l", "liter", "liters", "litre", "litres"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "us_gallon",
+            symbol: "gal",
+            aliases: &["gal", "gallon", "gallons"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(3.78541),
+        },
+        UnitDef {
+            _id: "imp_gallon",
+            symbol: "imp gal",
+            aliases: &["imp_gal", "gal_uk", "imperial_gallon"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(4.54609),
+        },
+        UnitDef {
+            _id: "quart",
+            symbol: "qt",
+            aliases: &["qt", "quart", "quarts"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(0.946353),
+        },
+        UnitDef {
+            _id: "pint",
+            symbol: "pt",
+            aliases: &["pt", "pint", "pints"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(0.473176),
+        },
+        UnitDef {
+            _id: "cup",
+            symbol: "cup",
+            aliases: &["cup", "cups"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(0.236588),
+        },
+        UnitDef {
+            _id: "fluid_ounce",
+            symbol: "fl oz",
+            aliases: &["floz", "fl_oz", "fluid_ounce", "fluid_ounces"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(0.0295735),
+        },
+        UnitDef {
+            _id: "tablespoon",
+            symbol: "tbsp",
+            aliases: &["tbsp", "tablespoon", "tablespoons"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(0.0147868),
+        },
+        UnitDef {
+            _id: "teaspoon",
+            symbol: "tsp",
+            aliases: &["tsp", "teaspoon", "teaspoons"],
+            category: Category::Volume,
+            conversion: Conversion::Factor(0.00492892),
+        },
+        // Speed (base: m/s)
+        UnitDef {
+            _id: "mps",
+            symbol: "m/s",
+            aliases: &["m/s", "mps", "meters_per_second"],
+            category: Category::Speed,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "kmh",
+            symbol: "km/h",
+            aliases: &["km/h", "kmh", "kph", "kilometers_per_hour"],
+            category: Category::Speed,
+            conversion: Conversion::Factor(0.277778),
+        },
+        UnitDef {
+            _id: "mph",
+            symbol: "mph",
+            aliases: &["mph", "miles_per_hour"],
+            category: Category::Speed,
+            conversion: Conversion::Factor(0.44704),
+        },
+        UnitDef {
+            _id: "knot",
+            symbol: "kn",
+            aliases: &["kn", "kt", "knot", "knots"],
+            category: Category::Speed,
+            conversion: Conversion::Factor(0.514444),
+        },
+        UnitDef {
+            _id: "fps",
+            symbol: "ft/s",
+            aliases: &["ft/s", "fps", "feet_per_second"],
+            category: Category::Speed,
+            conversion: Conversion::Factor(0.3048),
+        },
+        // Area (base: m²)
+        UnitDef {
+            _id: "sqmm",
+            symbol: "mm²",
+            aliases: &["mm2", "sqmm", "square_millimeter"],
+            category: Category::Area,
+            conversion: Conversion::Factor(0.000001),
+        },
+        UnitDef {
+            _id: "sqcm",
+            symbol: "cm²",
+            aliases: &["cm2", "sqcm", "square_centimeter"],
+            category: Category::Area,
+            conversion: Conversion::Factor(0.0001),
+        },
+        UnitDef {
+            _id: "sqm",
+            symbol: "m²",
+            aliases: &["m2", "sqm", "square_meter", "square_meters"],
+            category: Category::Area,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "sqkm",
+            symbol: "km²",
+            aliases: &["km2", "sqkm", "square_kilometer"],
+            category: Category::Area,
+            conversion: Conversion::Factor(1000000.0),
+        },
+        UnitDef {
+            _id: "sqft",
+            symbol: "ft²",
+            aliases: &["ft2", "sqft", "square_foot", "square_feet"],
+            category: Category::Area,
+            conversion: Conversion::Factor(0.092903),
+        },
+        UnitDef {
+            _id: "acre",
+            symbol: "ac",
+            aliases: &["ac", "acre", "acres"],
+            category: Category::Area,
+            conversion: Conversion::Factor(4046.86),
+        },
+        UnitDef {
+            _id: "hectare",
+            symbol: "ha",
+            aliases: &["ha", "hectare", "hectares"],
+            category: Category::Area,
+            conversion: Conversion::Factor(10000.0),
+        },
+        // Data (base: byte)
+        UnitDef {
+            _id: "byte",
+            symbol: "B",
+            aliases: &["b", "byte", "bytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "kilobyte",
+            symbol: "KB",
+            aliases: &["kb", "kilobyte", "kilobytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1000.0),
+        },
+        UnitDef {
+            _id: "megabyte",
+            symbol: "MB",
+            aliases: &["mb", "megabyte", "megabytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1_000_000.0),
+        },
+        UnitDef {
+            _id: "gigabyte",
+            symbol: "GB",
+            aliases: &["gb", "gigabyte", "gigabytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1_000_000_000.0),
+        },
+        UnitDef {
+            _id: "terabyte",
+            symbol: "TB",
+            aliases: &["tb", "terabyte", "terabytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1_000_000_000_000.0),
+        },
+        UnitDef {
+            _id: "kibibyte",
+            symbol: "KiB",
+            aliases: &["kib", "kibibyte", "kibibytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1024.0),
+        },
+        UnitDef {
+            _id: "mebibyte",
+            symbol: "MiB",
+            aliases: &["mib", "mebibyte", "mebibytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1_048_576.0),
+        },
+        UnitDef {
+            _id: "gibibyte",
+            symbol: "GiB",
+            aliases: &["gib", "gibibyte", "gibibytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1_073_741_824.0),
+        },
+        UnitDef {
+            _id: "tebibyte",
+            symbol: "TiB",
+            aliases: &["tib", "tebibyte", "tebibytes"],
+            category: Category::Data,
+            conversion: Conversion::Factor(1_099_511_627_776.0),
+        },
+        // Time (base: second)
+        UnitDef {
+            _id: "second",
+            symbol: "s",
+            aliases: &["s", "sec", "second", "seconds"],
+            category: Category::Time,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "minute",
+            symbol: "min",
+            aliases: &["min", "minute", "minutes"],
+            category: Category::Time,
+            conversion: Conversion::Factor(60.0),
+        },
+        UnitDef {
+            _id: "hour",
+            symbol: "h",
+            aliases: &["h", "hr", "hour", "hours"],
+            category: Category::Time,
+            conversion: Conversion::Factor(3600.0),
+        },
+        UnitDef {
+            _id: "day",
+            symbol: "d",
+            aliases: &["d", "day", "days"],
+            category: Category::Time,
+            conversion: Conversion::Factor(86400.0),
+        },
+        UnitDef {
+            _id: "week",
+            symbol: "wk",
+            aliases: &["wk", "week", "weeks"],
+            category: Category::Time,
+            conversion: Conversion::Factor(604800.0),
+        },
+        UnitDef {
+            _id: "month",
+            symbol: "mo",
+            aliases: &["mo", "month", "months"],
+            category: Category::Time,
+            conversion: Conversion::Factor(2_592_000.0),
+        },
+        UnitDef {
+            _id: "year",
+            symbol: "yr",
+            aliases: &["yr", "year", "years"],
+            category: Category::Time,
+            conversion: Conversion::Factor(31_536_000.0),
+        },
+        // Pressure (base: Pa)
+        UnitDef {
+            _id: "pascal",
+            symbol: "Pa",
+            aliases: &["pa", "pascal", "pascals"],
+            category: Category::Pressure,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "hectopascal",
+            symbol: "hPa",
+            aliases: &["hpa", "hectopascal"],
+            category: Category::Pressure,
+            conversion: Conversion::Factor(100.0),
+        },
+        UnitDef {
+            _id: "kilopascal",
+            symbol: "kPa",
+            aliases: &["kpa", "kilopascal"],
+            category: Category::Pressure,
+            conversion: Conversion::Factor(1000.0),
+        },
+        UnitDef {
+            _id: "bar",
+            symbol: "bar",
+            aliases: &["bar", "bars"],
+            category: Category::Pressure,
+            conversion: Conversion::Factor(100_000.0),
+        },
+        UnitDef {
+            _id: "millibar",
+            symbol: "mbar",
+            aliases: &["mbar", "millibar"],
+            category: Category::Pressure,
+            conversion: Conversion::Factor(100.0),
+        },
+        UnitDef {
+            _id: "psi",
+            symbol: "psi",
+            aliases: &["psi", "pounds_per_square_inch"],
+            category: Category::Pressure,
+            conversion: Conversion::Factor(6894.76),
+        },
+        UnitDef {
+            _id: "atmosphere",
+            symbol: "atm",
+            aliases: &["atm", "atmosphere", "atmospheres"],
+            category: Category::Pressure,
+            conversion: Conversion::Factor(101_325.0),
+        },
+        UnitDef {
+            _id: "mmhg",
+            symbol: "mmHg",
+            aliases: &["mmhg", "torr"],
+            category: Category::Pressure,
+            conversion: Conversion::Factor(133.322),
+        },
+        // Energy (base: Joule)
+        UnitDef {
+            _id: "joule",
+            symbol: "J",
+            aliases: &["j", "joule", "joules"],
+            category: Category::Energy,
+            conversion: Conversion::Factor(1.0),
+        },
+        UnitDef {
+            _id: "kilojoule",
+            symbol: "kJ",
+            aliases: &["kj", "kilojoule", "kilojoules"],
+            category: Category::Energy,
+            conversion: Conversion::Factor(1000.0),
+        },
+        UnitDef {
+            _id: "calorie",
+            symbol: "cal",
+            aliases: &["cal", "calorie", "calories"],
+            category: Category::Energy,
+            conversion: Conversion::Factor(4.184),
+        },
+        UnitDef {
+            _id: "kilocalorie",
+            symbol: "kcal",
+            aliases: &["kcal", "kilocalorie", "kilocalories"],
+            category: Category::Energy,
+            conversion: Conversion::Factor(4184.0),
+        },
+        UnitDef {
+            _id: "watt_hour",
+            symbol: "Wh",
+            aliases: &["wh", "watt_hour"],
+            category: Category::Energy,
+            conversion: Conversion::Factor(3600.0),
+        },
+        UnitDef {
+            _id: "kilowatt_hour",
+            symbol: "kWh",
+            aliases: &["kwh", "kilowatt_hour"],
+            category: Category::Energy,
+            conversion: Conversion::Factor(3_600_000.0),
+        },
+        UnitDef {
+            _id: "btu",
+            symbol: "BTU",
+            aliases: &["btu", "british_thermal_unit"],
+            category: Category::Energy,
+            conversion: Conversion::Factor(1055.06),
+        },
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_celsius_to_fahrenheit() {
+        let r = convert_to(&100.0, "c", "f").unwrap();
+        assert!((r.value - 212.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_fahrenheit_to_celsius() {
+        let r = convert_to(&32.0, "f", "c").unwrap();
+        assert!((r.value - 0.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_body_temp_f_to_c() {
+        let r = convert_to(&98.6, "f", "c").unwrap();
+        assert!((r.value - 37.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_km_to_miles() {
+        let r = convert_to(&100.0, "km", "mi").unwrap();
+        assert!((r.value - 62.1371).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_miles_to_km() {
+        let r = convert_to(&1.0, "mi", "km").unwrap();
+        assert!((r.value - 1.60934).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_kg_to_lb() {
+        let r = convert_to(&1.0, "kg", "lb").unwrap();
+        assert!((r.value - 2.20462).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_lb_to_kg() {
+        let r = convert_to(&100.0, "lbs", "kg").unwrap();
+        assert!((r.value - 45.3592).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_liters_to_gallons() {
+        let r = convert_to(&3.78541, "l", "gal").unwrap();
+        assert!((r.value - 1.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_kmh_to_mph() {
+        let r = convert_to(&100.0, "kmh", "mph").unwrap();
+        assert!((r.value - 62.1371).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_gb_to_mb() {
+        let r = convert_to(&1.0, "gb", "mb").unwrap();
+        assert!((r.value - 1000.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_gib_to_mib() {
+        let r = convert_to(&1.0, "gib", "mib").unwrap();
+        assert!((r.value - 1024.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_hours_to_minutes() {
+        let r = convert_to(&2.5, "h", "min").unwrap();
+        assert!((r.value - 150.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_bar_to_psi() {
+        let r = convert_to(&1.0, "bar", "psi").unwrap();
+        assert!((r.value - 14.5038).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_kcal_to_kj() {
+        let r = convert_to(&1.0, "kcal", "kj").unwrap();
+        assert!((r.value - 4.184).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_sqm_to_sqft() {
+        let r = convert_to(&1.0, "m2", "ft2").unwrap();
+        assert!((r.value - 10.7639).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_unknown_unit_returns_none() {
+        assert!(convert_to(&100.0, "xyz", "abc").is_none());
+    }
+
+    #[test]
+    fn test_cross_category_returns_none() {
+        assert!(convert_to(&100.0, "km", "kg").is_none());
+    }
+
+    #[test]
+    fn test_convert_common_returns_results() {
+        let results = convert_common(&100.0, "km");
+        assert!(!results.is_empty());
+        assert!(results.len() <= 5);
+    }
+
+    #[test]
+    fn test_convert_common_excludes_source() {
+        let results = convert_common(&100.0, "km");
+        for r in &results {
+            assert_ne!(r.target_symbol, "km");
+        }
+    }
+
+    #[test]
+    fn test_alias_case_insensitive() {
+        let r1 = convert_to(&100.0, "KM", "MI").unwrap();
+        let r2 = convert_to(&100.0, "km", "mi").unwrap();
+        assert!((r1.value - r2.value).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_full_name_alias() {
+        let r = convert_to(&100.0, "kilometers", "miles").unwrap();
+        assert!((r.value - 62.1371).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_format_currency_two_decimals() {
+        let r = convert_to(&1.0, "km", "mi").unwrap();
+        // display_value should have reasonable formatting
+        assert!(!r.display_value.is_empty());
+    }
+
+    #[test]
+    fn test_currency_alias_convert_to() {
+        // "dollar" and "euro" are aliases, not in the UNITS table
+        let r = convert_to(&20.0, "dollar", "euro");
+        // May return None if ECB rates unavailable (network), but should not panic
+        // In a network-available environment, this should return Some
+        if let Some(r) = r {
+            assert!(r.value > 0.0);
+            assert_eq!(r.target_symbol, "EUR");
+        }
+    }
+
+    #[test]
+    fn test_currency_alias_convert_common() {
+        let results = convert_common(&20.0, "dollar");
+        // May be empty if ECB rates unavailable, but should not panic
+        for r in &results {
+            assert!(r.value > 0.0);
+        }
+    }
+
+    #[test]
+    fn test_display_value_no_double_unit() {
+        let r = convert_to(&100.0, "km", "mi").unwrap();
+        // display_value should contain the symbol exactly once
+        let count = r.display_value.matches(&r.target_symbol).count();
+        assert_eq!(count, 1, "display_value '{}' should contain '{}' exactly once", r.display_value, r.target_symbol);
+    }
+}

crates/owlry-core/src/providers/lua_provider.rs

@@ -89,15 +89,15 @@ impl Provider for LuaProvider {
     }
 }
 
-// LuaProvider needs to be Send for the Provider trait
-// Since we're using Rc<RefCell<>>, we need to be careful about thread safety
-// For now, owlry is single-threaded, so this is safe
+// LuaProvider needs to be Send + Sync for the Provider trait.
+// Rc<RefCell<>> is !Send and !Sync, but the ProviderManager RwLock ensures
+// Rc<RefCell<>> is only accessed during refresh() (write lock = exclusive access).
+// Read-only operations (items(), search) only touch self.items (Vec<LaunchItem>).
 unsafe impl Send for LuaProvider {}
+unsafe impl Sync for LuaProvider {}
 
 /// Create LuaProviders from all registered providers in a plugin
-pub fn create_providers_from_plugin(
-    plugin: Rc<RefCell<LoadedPlugin>>,
-) -> Vec<Box<dyn Provider>> {
+pub fn create_providers_from_plugin(plugin: Rc<RefCell<LoadedPlugin>>) -> Vec<Box<dyn Provider>> {
     let registrations = {
         let p = plugin.borrow();
         match p.get_provider_registrations() {

crates/owlry-core/src/providers/native_provider.rs

@@ -9,7 +9,9 @@
 use std::sync::{Arc, RwLock};
 
 use log::debug;
-use owlry_plugin_api::{PluginItem as ApiPluginItem, ProviderHandle, ProviderInfo, ProviderKind, ProviderPosition};
+use owlry_plugin_api::{
+    PluginItem as ApiPluginItem, ProviderHandle, ProviderInfo, ProviderKind, ProviderPosition,
+};
 
 use super::{LaunchItem, Provider, ProviderType};
 use crate::plugins::native_loader::NativePlugin;
@@ -76,7 +78,10 @@ impl NativeProvider {
         }
 
         let api_items = self.plugin.query_provider(self.handle, query);
-        api_items.into_iter().map(|item| self.convert_item(item)).collect()
+        api_items
+            .into_iter()
+            .map(|item| self.convert_item(item))
+            .collect()
     }
 
     /// Check if this provider has a prefix that matches the query
@@ -116,6 +121,19 @@ impl NativeProvider {
         self.info.priority
     }
 
+    /// Get the provider's default icon name
+    pub fn icon(&self) -> &str {
+        self.info.icon.as_str()
+    }
+
+    /// Get the provider's display position as a string
+    pub fn position_str(&self) -> &str {
+        match self.info.position {
+            ProviderPosition::Widget => "widget",
+            ProviderPosition::Normal => "normal",
+        }
+    }
+
     /// Execute an action command on the provider
     /// Uses query with "!" prefix to trigger action handling in the plugin
     pub fn execute_action(&self, action: &str) {

crates/owlry-core/src/providers/system.rs

@@ -0,0 +1,148 @@
+use super::{LaunchItem, Provider, ProviderType};
+
+/// Built-in system provider. Returns a fixed set of power and session management actions.
+///
+/// This is a static provider — items are populated in `new()` and `refresh()` is a no-op.
+pub(crate) struct SystemProvider {
+    items: Vec<LaunchItem>,
+}
+
+impl SystemProvider {
+    pub fn new() -> Self {
+        let commands: &[(&str, &str, &str, &str, &str)] = &[
+            (
+                "shutdown",
+                "Shutdown",
+                "Power off the system",
+                "system-shutdown",
+                "systemctl poweroff",
+            ),
+            (
+                "reboot",
+                "Reboot",
+                "Restart the system",
+                "system-reboot",
+                "systemctl reboot",
+            ),
+            (
+                "reboot-bios",
+                "Reboot to BIOS",
+                "Restart into UEFI/BIOS setup",
+                "system-reboot",
+                "systemctl reboot --firmware-setup",
+            ),
+            (
+                "suspend",
+                "Suspend",
+                "Suspend to RAM",
+                "system-suspend",
+                "systemctl suspend",
+            ),
+            (
+                "hibernate",
+                "Hibernate",
+                "Suspend to disk",
+                "system-suspend-hibernate",
+                "systemctl hibernate",
+            ),
+            (
+                "lock",
+                "Lock Screen",
+                "Lock the session",
+                "system-lock-screen",
+                "loginctl lock-session",
+            ),
+            (
+                "logout",
+                "Log Out",
+                "End the current session",
+                "system-log-out",
+                "loginctl terminate-session self",
+            ),
+        ];
+
+        let items = commands
+            .iter()
+            .map(|(action_id, name, description, icon, command)| LaunchItem {
+                id: format!("sys:{}", action_id),
+                name: name.to_string(),
+                description: Some(description.to_string()),
+                icon: Some(icon.to_string()),
+                provider: ProviderType::Plugin("sys".into()),
+                command: command.to_string(),
+                terminal: false,
+                tags: vec!["system".into()],
+            })
+            .collect();
+
+        Self { items }
+    }
+}
+
+impl Provider for SystemProvider {
+    fn name(&self) -> &str {
+        "System"
+    }
+
+    fn provider_type(&self) -> ProviderType {
+        ProviderType::Plugin("sys".into())
+    }
+
+    fn refresh(&mut self) {
+        // Static provider — no-op
+    }
+
+    fn items(&self) -> &[LaunchItem] {
+        &self.items
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn has_seven_actions() {
+        let provider = SystemProvider::new();
+        assert_eq!(provider.items().len(), 7);
+    }
+
+    #[test]
+    fn contains_expected_action_names() {
+        let provider = SystemProvider::new();
+        let names: Vec<&str> = provider.items().iter().map(|i| i.name.as_str()).collect();
+        assert!(names.contains(&"Shutdown"));
+        assert!(names.contains(&"Reboot"));
+        assert!(names.contains(&"Lock Screen"));
+        assert!(names.contains(&"Log Out"));
+    }
+
+    #[test]
+    fn provider_type_is_sys_plugin() {
+        let provider = SystemProvider::new();
+        assert_eq!(provider.provider_type(), ProviderType::Plugin("sys".into()));
+    }
+
+    #[test]
+    fn shutdown_command_is_correct() {
+        let provider = SystemProvider::new();
+        let shutdown = provider
+            .items()
+            .iter()
+            .find(|i| i.name == "Shutdown")
+            .expect("Shutdown item must exist");
+        assert_eq!(shutdown.command, "systemctl poweroff");
+    }
+
+    #[test]
+    fn all_items_have_system_tag() {
+        let provider = SystemProvider::new();
+        for item in provider.items() {
+            assert!(
+                item.tags.contains(&"system".to_string()),
+                "item '{}' is missing 'system' tag",
+                item.name
+            );
+        }
+    }
+}

crates/owlry-core/src/server.rs

@@ -0,0 +1,286 @@
+use std::io::{self, BufRead, BufReader, Write};
+use std::os::unix::fs::PermissionsExt;
+use std::os::unix::net::{UnixListener, UnixStream};
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, RwLock};
+use std::time::Duration;
+use std::thread;
+
+/// Maximum allowed size for a single IPC request line (1 MiB).
+const MAX_REQUEST_SIZE: usize = 1_048_576;
+
+use log::{error, info, warn};
+
+use crate::config::Config;
+use crate::data::FrecencyStore;
+use crate::filter::ProviderFilter;
+use crate::ipc::{ProviderDesc, Request, Response, ResultItem};
+use crate::providers::{LaunchItem, ProviderManager};
+
+/// IPC server that listens on a Unix domain socket and dispatches
+/// requests to the provider system.
+pub struct Server {
+    listener: UnixListener,
+    socket_path: PathBuf,
+    provider_manager: Arc<RwLock<ProviderManager>>,
+    frecency: Arc<RwLock<FrecencyStore>>,
+    config: Arc<Config>,
+}
+
+impl Server {
+    /// Bind to the given socket path, loading config and creating a ProviderManager.
+    ///
+    /// Removes a stale socket file if one already exists at the path.
+    pub fn bind(socket_path: &Path) -> io::Result<Self> {
+        // Remove stale socket if present
+        if socket_path.exists() {
+            info!("Removing stale socket at {:?}", socket_path);
+            std::fs::remove_file(socket_path)?;
+        }
+
+        let listener = UnixListener::bind(socket_path)?;
+        std::fs::set_permissions(socket_path, std::fs::Permissions::from_mode(0o600))?;
+        info!("IPC server listening on {:?}", socket_path);
+
+        let config = Config::load_or_default();
+        let provider_manager = ProviderManager::new_with_config(&config);
+        let frecency = FrecencyStore::new();
+
+        Ok(Self {
+            listener,
+            socket_path: socket_path.to_path_buf(),
+            provider_manager: Arc::new(RwLock::new(provider_manager)),
+            frecency: Arc::new(RwLock::new(frecency)),
+            config: Arc::new(config),
+        })
+    }
+
+    /// Accept connections in a loop, spawning a thread per client.
+    pub fn run(&self) -> io::Result<()> {
+        // Start filesystem watcher for user plugin hot-reload
+        crate::plugins::watcher::start_watching(Arc::clone(&self.provider_manager));
+
+        info!("Server entering accept loop");
+        for stream in self.listener.incoming() {
+            match stream {
+                Ok(stream) => {
+                    let pm = Arc::clone(&self.provider_manager);
+                    let frecency = Arc::clone(&self.frecency);
+                    let config = Arc::clone(&self.config);
+                    thread::spawn(move || {
+                        if let Err(e) = Self::handle_client(stream, pm, frecency, config) {
+                            warn!("Client handler error: {}", e);
+                        }
+                    });
+                }
+                Err(e) => {
+                    error!("Failed to accept connection: {}", e);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Accept one connection and handle all its requests until EOF.
+    ///
+    /// Intended for integration tests where spawning a full accept loop
+    /// is unnecessary.
+    pub fn handle_one_for_testing(&self) -> io::Result<()> {
+        let (stream, _addr) = self.listener.accept()?;
+        Self::handle_client(
+            stream,
+            Arc::clone(&self.provider_manager),
+            Arc::clone(&self.frecency),
+            Arc::clone(&self.config),
+        )
+    }
+
+    /// Read newline-delimited JSON requests from a single client stream,
+    /// dispatch each, and write the JSON response back.
+    fn handle_client(
+        stream: UnixStream,
+        pm: Arc<RwLock<ProviderManager>>,
+        frecency: Arc<RwLock<FrecencyStore>>,
+        config: Arc<Config>,
+    ) -> io::Result<()> {
+        stream.set_read_timeout(Some(Duration::from_secs(30)))?;
+        let mut reader = BufReader::new(stream.try_clone()?);
+        let mut writer = stream;
+
+        loop {
+            let mut line = String::new();
+            let bytes_read = reader.read_line(&mut line)?;
+            if bytes_read == 0 {
+                break;
+            }
+
+            if line.len() > MAX_REQUEST_SIZE {
+                let resp = Response::Error {
+                    message: format!(
+                        "request too large ({} bytes, max {})",
+                        line.len(),
+                        MAX_REQUEST_SIZE
+                    ),
+                };
+                write_response(&mut writer, &resp)?;
+                break;
+            }
+
+            let trimmed = line.trim();
+            if trimmed.is_empty() {
+                continue;
+            }
+
+            let request: Request = match serde_json::from_str(trimmed) {
+                Ok(req) => req,
+                Err(e) => {
+                    warn!("Malformed request from client: {}", e);
+                    let resp = Response::Error {
+                        message: format!("invalid request JSON: {}", e),
+                    };
+                    write_response(&mut writer, &resp)?;
+                    continue;
+                }
+            };
+
+            let response = Self::handle_request(&request, &pm, &frecency, &config);
+            write_response(&mut writer, &response)?;
+        }
+
+        Ok(())
+    }
+
+    /// Dispatch a single request to the appropriate subsystem and return
+    /// the response.
+    fn handle_request(
+        request: &Request,
+        pm: &Arc<RwLock<ProviderManager>>,
+        frecency: &Arc<RwLock<FrecencyStore>>,
+        config: &Arc<Config>,
+    ) -> Response {
+        match request {
+            Request::Query { text, modes } => {
+                let filter = match modes {
+                    Some(m) => ProviderFilter::from_mode_strings(m),
+                    None => ProviderFilter::all(),
+                };
+                let max = config.general.max_results;
+                let weight = config.providers.frecency_weight;
+
+                let pm_guard = pm.read().unwrap_or_else(|e| e.into_inner());
+                let frecency_guard = frecency.read().unwrap_or_else(|e| e.into_inner());
+                let results = pm_guard.search_with_frecency(
+                    text,
+                    max,
+                    &filter,
+                    &frecency_guard,
+                    weight,
+                    None,
+                );
+
+                Response::Results {
+                    items: results
+                        .into_iter()
+                        .map(|(item, score)| launch_item_to_result(item, score))
+                        .collect(),
+                }
+            }
+
+            Request::Launch {
+                item_id,
+                provider: _,
+            } => {
+                let mut frecency_guard = frecency.write().unwrap_or_else(|e| e.into_inner());
+                frecency_guard.record_launch(item_id);
+                Response::Ack
+            }
+
+            Request::Providers => {
+                let pm_guard = pm.read().unwrap_or_else(|e| e.into_inner());
+                let descs = pm_guard.available_providers();
+                Response::Providers {
+                    list: descs.into_iter().map(descriptor_to_desc).collect(),
+                }
+            }
+
+            Request::Refresh { provider } => {
+                let mut pm_guard = pm.write().unwrap_or_else(|e| e.into_inner());
+                pm_guard.refresh_provider(provider);
+                Response::Ack
+            }
+
+            Request::Toggle => {
+                // Toggle visibility is a client-side concern; the daemon just acks.
+                Response::Ack
+            }
+
+            Request::Submenu { plugin_id, data } => {
+                let pm_guard = pm.read().unwrap_or_else(|e| e.into_inner());
+                match pm_guard.query_submenu_actions(plugin_id, data, plugin_id) {
+                    Some((_name, actions)) => Response::SubmenuItems {
+                        items: actions
+                            .into_iter()
+                            .map(|item| launch_item_to_result(item, 0))
+                            .collect(),
+                    },
+                    None => Response::Error {
+                        message: format!("no submenu actions for plugin '{}'", plugin_id),
+                    },
+                }
+            }
+
+            Request::PluginAction { command } => {
+                let pm_guard = pm.read().unwrap_or_else(|e| e.into_inner());
+                if pm_guard.execute_plugin_action(command) {
+                    Response::Ack
+                } else {
+                    Response::Error {
+                        message: format!("no plugin handled action '{}'", command),
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl Drop for Server {
+    fn drop(&mut self) {
+        // Best-effort cleanup of the socket file
+        if self.socket_path.exists() {
+            let _ = std::fs::remove_file(&self.socket_path);
+        }
+    }
+}
+
+/// Serialize a response as a single JSON line terminated by newline.
+fn write_response(writer: &mut UnixStream, response: &Response) -> io::Result<()> {
+    let mut json = serde_json::to_string(response)
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+    json.push('\n');
+    writer.write_all(json.as_bytes())?;
+    writer.flush()
+}
+
+fn launch_item_to_result(item: LaunchItem, score: i64) -> ResultItem {
+    ResultItem {
+        id: item.id,
+        title: item.name,
+        description: item.description.unwrap_or_default(),
+        icon: item.icon.unwrap_or_default(),
+        provider: format!("{}", item.provider),
+        score,
+        command: Some(item.command),
+        terminal: item.terminal,
+        tags: item.tags,
+    }
+}
+
+fn descriptor_to_desc(desc: crate::providers::ProviderDescriptor) -> ProviderDesc {
+    ProviderDesc {
+        id: desc.id,
+        name: desc.name,
+        prefix: desc.prefix,
+        icon: desc.icon,
+        position: desc.position,
+    }
+}

crates/owlry-core/tests/ipc_test.rs

@@ -0,0 +1,148 @@
+use owlry_core::ipc::{ProviderDesc, Request, Response, ResultItem};
+
+#[test]
+fn test_query_request_roundtrip() {
+    let req = Request::Query {
+        text: "fire".into(),
+        modes: Some(vec!["app".into(), "cmd".into()]),
+    };
+    let json = serde_json::to_string(&req).unwrap();
+    let parsed: Request = serde_json::from_str(&json).unwrap();
+    assert_eq!(req, parsed);
+}
+
+#[test]
+fn test_query_request_without_modes() {
+    let req = Request::Query {
+        text: "fire".into(),
+        modes: None,
+    };
+    let json = serde_json::to_string(&req).unwrap();
+    assert!(!json.contains("modes"));
+    let parsed: Request = serde_json::from_str(&json).unwrap();
+    assert_eq!(req, parsed);
+}
+
+#[test]
+fn test_launch_request_roundtrip() {
+    let req = Request::Launch {
+        item_id: "firefox.desktop".into(),
+        provider: "app".into(),
+    };
+    let json = serde_json::to_string(&req).unwrap();
+    let parsed: Request = serde_json::from_str(&json).unwrap();
+    assert_eq!(req, parsed);
+}
+
+#[test]
+fn test_results_response_roundtrip() {
+    let resp = Response::Results {
+        items: vec![ResultItem {
+            id: "firefox.desktop".into(),
+            title: "Firefox".into(),
+            description: "Web Browser".into(),
+            icon: "firefox".into(),
+            provider: "app".into(),
+            score: 95,
+            command: Some("firefox".into()),
+            terminal: false,
+            tags: vec![],
+        }],
+    };
+    let json = serde_json::to_string(&resp).unwrap();
+    let parsed: Response = serde_json::from_str(&json).unwrap();
+    assert_eq!(resp, parsed);
+}
+
+#[test]
+fn test_providers_response() {
+    let resp = Response::Providers {
+        list: vec![ProviderDesc {
+            id: "app".into(),
+            name: "Applications".into(),
+            prefix: Some(":app".into()),
+            icon: "application-x-executable".into(),
+            position: "normal".into(),
+        }],
+    };
+    let json = serde_json::to_string(&resp).unwrap();
+    let parsed: Response = serde_json::from_str(&json).unwrap();
+    assert_eq!(resp, parsed);
+}
+
+#[test]
+fn test_error_response() {
+    let resp = Response::Error {
+        message: "plugin not found".into(),
+    };
+    let json = serde_json::to_string(&resp).unwrap();
+    let parsed: Response = serde_json::from_str(&json).unwrap();
+    assert_eq!(resp, parsed);
+}
+
+#[test]
+fn test_toggle_request() {
+    let req = Request::Toggle;
+    let json = serde_json::to_string(&req).unwrap();
+    let parsed: Request = serde_json::from_str(&json).unwrap();
+    assert_eq!(req, parsed);
+}
+
+#[test]
+fn test_submenu_request() {
+    let req = Request::Submenu {
+        plugin_id: "systemd".into(),
+        data: "docker.service".into(),
+    };
+    let json = serde_json::to_string(&req).unwrap();
+    let parsed: Request = serde_json::from_str(&json).unwrap();
+    assert_eq!(req, parsed);
+}
+
+#[test]
+fn test_refresh_request() {
+    let req = Request::Refresh {
+        provider: "clipboard".into(),
+    };
+    let json = serde_json::to_string(&req).unwrap();
+    let parsed: Request = serde_json::from_str(&json).unwrap();
+    assert_eq!(req, parsed);
+}
+
+#[test]
+fn test_plugin_action_request() {
+    let req = Request::PluginAction {
+        command: "POMODORO:start".into(),
+    };
+    let json = serde_json::to_string(&req).unwrap();
+    let parsed: Request = serde_json::from_str(&json).unwrap();
+    assert_eq!(req, parsed);
+}
+
+#[test]
+fn test_terminal_field_defaults_false() {
+    // terminal field should default to false when missing from JSON
+    let json =
+        r#"{"id":"test","title":"Test","description":"","icon":"","provider":"cmd","score":0}"#;
+    let item: ResultItem = serde_json::from_str(json).unwrap();
+    assert!(!item.terminal);
+}
+
+#[test]
+fn test_terminal_field_roundtrip() {
+    let item = ResultItem {
+        id: "htop".into(),
+        title: "htop".into(),
+        description: "Process viewer".into(),
+        icon: "htop".into(),
+        provider: "cmd".into(),
+        score: 50,
+        command: Some("htop".into()),
+        terminal: true,
+        tags: vec![],
+    };
+    let json = serde_json::to_string(&item).unwrap();
+    assert!(json.contains("\"terminal\":true"));
+    let parsed: ResultItem = serde_json::from_str(&json).unwrap();
+    assert!(parsed.terminal);
+}

crates/owlry-core/tests/server_test.rs

@@ -0,0 +1,239 @@
+use std::io::{BufRead, BufReader, Write};
+use std::os::unix::net::UnixStream;
+use std::thread;
+
+use owlry_core::ipc::{Request, Response};
+use owlry_core::server::Server;
+
+/// Helper: send a JSON request line and read the JSON response line.
+fn roundtrip(stream: &mut UnixStream, request: &Request) -> Response {
+    let mut line = serde_json::to_string(request).unwrap();
+    line.push('\n');
+    stream.write_all(line.as_bytes()).unwrap();
+    stream.flush().unwrap();
+
+    let mut reader = BufReader::new(stream.try_clone().unwrap());
+    let mut buf = String::new();
+    reader.read_line(&mut buf).unwrap();
+    serde_json::from_str(buf.trim()).unwrap()
+}
+
+#[test]
+fn test_server_responds_to_providers_request() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("owlry-test.sock");
+
+    let server = Server::bind(&sock).unwrap();
+
+    // Spawn the server to handle exactly one connection
+    let handle = thread::spawn(move || {
+        server.handle_one_for_testing().unwrap();
+    });
+
+    // Connect as a client
+    let mut stream = UnixStream::connect(&sock).unwrap();
+    let resp = roundtrip(&mut stream, &Request::Providers);
+
+    match resp {
+        Response::Providers { list } => {
+            // The default ProviderManager always has at least Application and Command
+            assert!(
+                list.len() >= 2,
+                "expected at least 2 providers, got {}",
+                list.len()
+            );
+            let ids: Vec<&str> = list.iter().map(|p| p.id.as_str()).collect();
+            assert!(ids.contains(&"app"), "missing 'app' provider");
+            assert!(ids.contains(&"cmd"), "missing 'cmd' provider");
+        }
+        other => panic!("expected Providers response, got: {:?}", other),
+    }
+
+    drop(stream);
+    handle.join().unwrap();
+}
+
+#[test]
+fn test_server_handles_launch_request() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("owlry-test.sock");
+
+    let server = Server::bind(&sock).unwrap();
+
+    let handle = thread::spawn(move || {
+        server.handle_one_for_testing().unwrap();
+    });
+
+    let mut stream = UnixStream::connect(&sock).unwrap();
+    let req = Request::Launch {
+        item_id: "firefox.desktop".into(),
+        provider: "app".into(),
+    };
+    let resp = roundtrip(&mut stream, &req);
+
+    assert_eq!(resp, Response::Ack);
+
+    drop(stream);
+    handle.join().unwrap();
+}
+
+#[test]
+fn test_server_handles_query_request() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("owlry-test.sock");
+
+    let server = Server::bind(&sock).unwrap();
+
+    let handle = thread::spawn(move || {
+        server.handle_one_for_testing().unwrap();
+    });
+
+    let mut stream = UnixStream::connect(&sock).unwrap();
+    let req = Request::Query {
+        text: "nonexistent_query_xyz".into(),
+        modes: None,
+    };
+    let resp = roundtrip(&mut stream, &req);
+
+    match resp {
+        Response::Results { items } => {
+            // A nonsense query should return empty or very few results
+            // (no items will fuzzy-match "nonexistent_query_xyz")
+            assert!(
+                items.len() <= 5,
+                "expected few/no results for gibberish query"
+            );
+        }
+        other => panic!("expected Results response, got: {:?}", other),
+    }
+
+    drop(stream);
+    handle.join().unwrap();
+}
+
+#[test]
+fn test_server_handles_toggle_request() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("owlry-test.sock");
+
+    let server = Server::bind(&sock).unwrap();
+
+    let handle = thread::spawn(move || {
+        server.handle_one_for_testing().unwrap();
+    });
+
+    let mut stream = UnixStream::connect(&sock).unwrap();
+    let resp = roundtrip(&mut stream, &Request::Toggle);
+
+    assert_eq!(resp, Response::Ack);
+
+    drop(stream);
+    handle.join().unwrap();
+}
+
+#[test]
+fn test_server_handles_refresh_request() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("owlry-test.sock");
+
+    let server = Server::bind(&sock).unwrap();
+
+    let handle = thread::spawn(move || {
+        server.handle_one_for_testing().unwrap();
+    });
+
+    let mut stream = UnixStream::connect(&sock).unwrap();
+    let req = Request::Refresh {
+        provider: "app".into(),
+    };
+    let resp = roundtrip(&mut stream, &req);
+
+    assert_eq!(resp, Response::Ack);
+
+    drop(stream);
+    handle.join().unwrap();
+}
+
+#[test]
+fn test_server_handles_submenu_for_unknown_plugin() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("owlry-test.sock");
+
+    let server = Server::bind(&sock).unwrap();
+
+    let handle = thread::spawn(move || {
+        server.handle_one_for_testing().unwrap();
+    });
+
+    let mut stream = UnixStream::connect(&sock).unwrap();
+    let req = Request::Submenu {
+        plugin_id: "nonexistent_plugin".into(),
+        data: "some_data".into(),
+    };
+    let resp = roundtrip(&mut stream, &req);
+
+    match resp {
+        Response::Error { message } => {
+            assert!(
+                message.contains("nonexistent_plugin"),
+                "error should mention the plugin id"
+            );
+        }
+        other => panic!(
+            "expected Error response for unknown plugin, got: {:?}",
+            other
+        ),
+    }
+
+    drop(stream);
+    handle.join().unwrap();
+}
+
+#[test]
+fn test_server_handles_multiple_requests_per_connection() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("owlry-test.sock");
+
+    let server = Server::bind(&sock).unwrap();
+
+    let handle = thread::spawn(move || {
+        server.handle_one_for_testing().unwrap();
+    });
+
+    let mut stream = UnixStream::connect(&sock).unwrap();
+
+    // Send Providers request
+    let resp1 = roundtrip(&mut stream, &Request::Providers);
+    assert!(matches!(resp1, Response::Providers { .. }));
+
+    // Send Toggle request on same connection
+    let resp2 = roundtrip(&mut stream, &Request::Toggle);
+    assert_eq!(resp2, Response::Ack);
+
+    drop(stream);
+    handle.join().unwrap();
+}
+
+#[test]
+fn test_server_cleans_up_stale_socket() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("owlry-test.sock");
+
+    // Create a stale socket file
+    std::os::unix::net::UnixListener::bind(&sock).unwrap();
+    assert!(sock.exists());
+
+    // Server::bind should succeed by removing the stale socket
+    let server = Server::bind(&sock).unwrap();
+
+    let handle = thread::spawn(move || {
+        server.handle_one_for_testing().unwrap();
+    });
+
+    let mut stream = UnixStream::connect(&sock).unwrap();
+    let resp = roundtrip(&mut stream, &Request::Toggle);
+    assert_eq!(resp, Response::Ack);
+
+    drop(stream);
+    handle.join().unwrap();
+}

crates/owlry-lua/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "owlry-lua"
-version = "0.4.9"
+version = "1.1.1"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
@@ -20,7 +20,7 @@ owlry-plugin-api = { path = "../owlry-plugin-api" }
 abi_stable = "0.11"
 
 # Lua runtime
-mlua = { version = "0.10", features = ["lua54", "vendored", "send", "serialize"] }
+mlua = { version = "0.11", features = ["lua54", "vendored", "send", "serialize"] }
 
 # Plugin manifest parsing
 toml = "0.8"
@@ -31,7 +31,7 @@ serde_json = "1.0"
 semver = "1"
 
 # HTTP client for plugins
-reqwest = { version = "0.12", features = ["blocking", "json"] }
+reqwest = { version = "0.13", features = ["blocking", "json"] }
 
 # Math expression evaluation
 meval = "0.2"

crates/owlry-lua/src/api/provider.rs

@@ -22,13 +22,16 @@ pub fn register_provider_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
 }
 
 /// Implementation of owlry.provider.register()
-fn register_provider(_lua: &Lua, config: Table) -> LuaResult<()> {
+fn register_provider(lua: &Lua, config: Table) -> LuaResult<()> {
     let name: String = config.get("name")?;
-    let display_name: String = config.get::<Option<String>>("display_name")?
+    let display_name: String = config
+        .get::<Option<String>>("display_name")?
         .unwrap_or_else(|| name.clone());
-    let type_id: String = config.get::<Option<String>>("type_id")?
+    let type_id: String = config
+        .get::<Option<String>>("type_id")?
         .unwrap_or_else(|| name.replace('-', "_"));
-    let default_icon: String = config.get::<Option<String>>("default_icon")?
+    let default_icon: String = config
+        .get::<Option<String>>("default_icon")?
         .unwrap_or_else(|| "application-x-addon".to_string());
     let prefix: Option<String> = config.get("prefix")?;
 
@@ -44,6 +47,21 @@ fn register_provider(_lua: &Lua, config: Table) -> LuaResult<()> {
 
     let is_dynamic = has_query;
 
+    // Store the config table in owlry.provider._registrations[name]
+    // so call_refresh/call_query can find the callback functions later
+    let globals = lua.globals();
+    let owlry: Table = globals.get("owlry")?;
+    let provider: Table = owlry.get("provider")?;
+    let registrations: Table = match provider.get::<Value>("_registrations")? {
+        Value::Table(t) => t,
+        _ => {
+            let t = lua.create_table()?;
+            provider.set("_registrations", t.clone())?;
+            t
+        }
+    };
+    registrations.set(name.as_str(), config)?;
+
     REGISTRATIONS.with(|regs| {
         regs.borrow_mut().push(ProviderRegistration {
             name,
@@ -116,13 +134,14 @@ fn call_provider_function(
     // First check if there's a _providers table
     if let Ok(Value::Table(providers)) = globals.get::<Value>("_owlry_providers")
         && let Ok(Value::Table(config)) = providers.get::<Value>(provider_name)
-            && let Ok(Value::Function(func)) = config.get::<Value>(function_name) {
-                let result: Value = match query {
-                    Some(q) => func.call(q)?,
-                    None => func.call(())?,
-                };
-                return parse_items_result(result);
-            }
+        && let Ok(Value::Function(func)) = config.get::<Value>(function_name)
+    {
+        let result: Value = match query {
+            Some(q) => func.call(q)?,
+            None => func.call(())?,
+        };
+        return parse_items_result(result);
+    }
 
     // Fall back: search through globals for functions
     // This is less reliable but handles simple cases
@@ -153,7 +172,9 @@ fn parse_item(table: &Table) -> LuaResult<PluginItem> {
     let description: Option<String> = table.get("description")?;
     let icon: Option<String> = table.get("icon")?;
     let terminal: bool = table.get::<Option<bool>>("terminal")?.unwrap_or(false);
-    let tags: Vec<String> = table.get::<Option<Vec<String>>>("tags")?.unwrap_or_default();
+    let tags: Vec<String> = table
+        .get::<Option<Vec<String>>>("tags")?
+        .unwrap_or_default();
 
     let mut item = PluginItem::new(id, name, command);
 
@@ -176,7 +197,7 @@ fn parse_item(table: &Table) -> LuaResult<PluginItem> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::runtime::{create_lua_runtime, SandboxConfig};
+    use crate::runtime::{SandboxConfig, create_lua_runtime};
 
     #[test]
     fn test_register_static_provider() {

crates/owlry-lua/src/api/utils.rs

@@ -11,25 +11,37 @@ use std::path::{Path, PathBuf};
 pub fn register_log_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     let log = lua.create_table()?;
 
-    log.set("debug", lua.create_function(|_, msg: String| {
-        eprintln!("[DEBUG] {}", msg);
-        Ok(())
-    })?)?;
+    log.set(
+        "debug",
+        lua.create_function(|_, msg: String| {
+            eprintln!("[DEBUG] {}", msg);
+            Ok(())
+        })?,
+    )?;
 
-    log.set("info", lua.create_function(|_, msg: String| {
-        eprintln!("[INFO] {}", msg);
-        Ok(())
-    })?)?;
+    log.set(
+        "info",
+        lua.create_function(|_, msg: String| {
+            eprintln!("[INFO] {}", msg);
+            Ok(())
+        })?,
+    )?;
 
-    log.set("warn", lua.create_function(|_, msg: String| {
-        eprintln!("[WARN] {}", msg);
-        Ok(())
-    })?)?;
+    log.set(
+        "warn",
+        lua.create_function(|_, msg: String| {
+            eprintln!("[WARN] {}", msg);
+            Ok(())
+        })?,
+    )?;
 
-    log.set("error", lua.create_function(|_, msg: String| {
-        eprintln!("[ERROR] {}", msg);
-        Ok(())
-    })?)?;
+    log.set(
+        "error",
+        lua.create_function(|_, msg: String| {
+            eprintln!("[ERROR] {}", msg);
+            Ok(())
+        })?,
+    )?;
 
     owlry.set("log", log)?;
     Ok(())
@@ -44,59 +56,79 @@ pub fn register_path_api(lua: &Lua, owlry: &Table, plugin_dir: &Path) -> LuaResu
     let path = lua.create_table()?;
 
     // owlry.path.config() -> ~/.config/owlry
-    path.set("config", lua.create_function(|_, ()| {
-        Ok(dirs::config_dir()
-            .map(|d| d.join("owlry"))
-            .map(|p| p.to_string_lossy().to_string())
-            .unwrap_or_default())
-    })?)?;
+    path.set(
+        "config",
+        lua.create_function(|_, ()| {
+            Ok(dirs::config_dir()
+                .map(|d| d.join("owlry"))
+                .map(|p| p.to_string_lossy().to_string())
+                .unwrap_or_default())
+        })?,
+    )?;
 
     // owlry.path.data() -> ~/.local/share/owlry
-    path.set("data", lua.create_function(|_, ()| {
-        Ok(dirs::data_dir()
-            .map(|d| d.join("owlry"))
-            .map(|p| p.to_string_lossy().to_string())
-            .unwrap_or_default())
-    })?)?;
+    path.set(
+        "data",
+        lua.create_function(|_, ()| {
+            Ok(dirs::data_dir()
+                .map(|d| d.join("owlry"))
+                .map(|p| p.to_string_lossy().to_string())
+                .unwrap_or_default())
+        })?,
+    )?;
 
     // owlry.path.cache() -> ~/.cache/owlry
-    path.set("cache", lua.create_function(|_, ()| {
-        Ok(dirs::cache_dir()
-            .map(|d| d.join("owlry"))
-            .map(|p| p.to_string_lossy().to_string())
-            .unwrap_or_default())
-    })?)?;
+    path.set(
+        "cache",
+        lua.create_function(|_, ()| {
+            Ok(dirs::cache_dir()
+                .map(|d| d.join("owlry"))
+                .map(|p| p.to_string_lossy().to_string())
+                .unwrap_or_default())
+        })?,
+    )?;
 
     // owlry.path.home() -> ~
-    path.set("home", lua.create_function(|_, ()| {
-        Ok(dirs::home_dir()
-            .map(|p| p.to_string_lossy().to_string())
-            .unwrap_or_default())
-    })?)?;
+    path.set(
+        "home",
+        lua.create_function(|_, ()| {
+            Ok(dirs::home_dir()
+                .map(|p| p.to_string_lossy().to_string())
+                .unwrap_or_default())
+        })?,
+    )?;
 
     // owlry.path.join(...) -> joined path
-    path.set("join", lua.create_function(|_, parts: mlua::Variadic<String>| {
-        let mut path = PathBuf::new();
-        for part in parts {
-            path.push(part);
-        }
-        Ok(path.to_string_lossy().to_string())
-    })?)?;
+    path.set(
+        "join",
+        lua.create_function(|_, parts: mlua::Variadic<String>| {
+            let mut path = PathBuf::new();
+            for part in parts {
+                path.push(part);
+            }
+            Ok(path.to_string_lossy().to_string())
+        })?,
+    )?;
 
     // owlry.path.plugin_dir() -> plugin directory
     let plugin_dir_str = plugin_dir.to_string_lossy().to_string();
-    path.set("plugin_dir", lua.create_function(move |_, ()| {
-        Ok(plugin_dir_str.clone())
-    })?)?;
+    path.set(
+        "plugin_dir",
+        lua.create_function(move |_, ()| Ok(plugin_dir_str.clone()))?,
+    )?;
 
     // owlry.path.expand(path) -> expanded path (~ -> home)
-    path.set("expand", lua.create_function(|_, path: String| {
-        if path.starts_with("~/")
-            && let Some(home) = dirs::home_dir() {
+    path.set(
+        "expand",
+        lua.create_function(|_, path: String| {
+            if path.starts_with("~/")
+                && let Some(home) = dirs::home_dir()
+            {
                 return Ok(home.join(&path[2..]).to_string_lossy().to_string());
             }
-        Ok(path)
-    })?)?;
+            Ok(path)
+        })?,
+    )?;
 
     owlry.set("path", path)?;
     Ok(())
@@ -111,76 +143,95 @@ pub fn register_fs_api(lua: &Lua, owlry: &Table, _plugin_dir: &Path) -> LuaResul
     let fs = lua.create_table()?;
 
     // owlry.fs.exists(path) -> bool
-    fs.set("exists", lua.create_function(|_, path: String| {
-        let path = expand_path(&path);
-        Ok(Path::new(&path).exists())
-    })?)?;
+    fs.set(
+        "exists",
+        lua.create_function(|_, path: String| {
+            let path = expand_path(&path);
+            Ok(Path::new(&path).exists())
+        })?,
+    )?;
 
     // owlry.fs.is_dir(path) -> bool
-    fs.set("is_dir", lua.create_function(|_, path: String| {
-        let path = expand_path(&path);
-        Ok(Path::new(&path).is_dir())
-    })?)?;
+    fs.set(
+        "is_dir",
+        lua.create_function(|_, path: String| {
+            let path = expand_path(&path);
+            Ok(Path::new(&path).is_dir())
+        })?,
+    )?;
 
     // owlry.fs.read(path) -> string or nil
-    fs.set("read", lua.create_function(|_, path: String| {
-        let path = expand_path(&path);
-        match std::fs::read_to_string(&path) {
-            Ok(content) => Ok(Some(content)),
-            Err(_) => Ok(None),
-        }
-    })?)?;
+    fs.set(
+        "read",
+        lua.create_function(|_, path: String| {
+            let path = expand_path(&path);
+            match std::fs::read_to_string(&path) {
+                Ok(content) => Ok(Some(content)),
+                Err(_) => Ok(None),
+            }
+        })?,
+    )?;
 
     // owlry.fs.read_lines(path) -> table of strings or nil
-    fs.set("read_lines", lua.create_function(|lua, path: String| {
-        let path = expand_path(&path);
-        match std::fs::read_to_string(&path) {
-            Ok(content) => {
-                let lines: Vec<String> = content.lines().map(|s| s.to_string()).collect();
-                Ok(Some(lua.create_sequence_from(lines)?))
+    fs.set(
+        "read_lines",
+        lua.create_function(|lua, path: String| {
+            let path = expand_path(&path);
+            match std::fs::read_to_string(&path) {
+                Ok(content) => {
+                    let lines: Vec<String> = content.lines().map(|s| s.to_string()).collect();
+                    Ok(Some(lua.create_sequence_from(lines)?))
+                }
+                Err(_) => Ok(None),
             }
-            Err(_) => Ok(None),
-        }
-    })?)?;
+        })?,
+    )?;
 
     // owlry.fs.list_dir(path) -> table of filenames or nil
-    fs.set("list_dir", lua.create_function(|lua, path: String| {
-        let path = expand_path(&path);
-        match std::fs::read_dir(&path) {
-            Ok(entries) => {
-                let names: Vec<String> = entries
-                    .filter_map(|e| e.ok())
-                    .filter_map(|e| e.file_name().into_string().ok())
-                    .collect();
-                Ok(Some(lua.create_sequence_from(names)?))
+    fs.set(
+        "list_dir",
+        lua.create_function(|lua, path: String| {
+            let path = expand_path(&path);
+            match std::fs::read_dir(&path) {
+                Ok(entries) => {
+                    let names: Vec<String> = entries
+                        .filter_map(|e| e.ok())
+                        .filter_map(|e| e.file_name().into_string().ok())
+                        .collect();
+                    Ok(Some(lua.create_sequence_from(names)?))
+                }
+                Err(_) => Ok(None),
             }
-            Err(_) => Ok(None),
-        }
-    })?)?;
+        })?,
+    )?;
 
     // owlry.fs.read_json(path) -> table or nil
-    fs.set("read_json", lua.create_function(|lua, path: String| {
-        let path = expand_path(&path);
-        match std::fs::read_to_string(&path) {
-            Ok(content) => {
-                match serde_json::from_str::<serde_json::Value>(&content) {
+    fs.set(
+        "read_json",
+        lua.create_function(|lua, path: String| {
+            let path = expand_path(&path);
+            match std::fs::read_to_string(&path) {
+                Ok(content) => match serde_json::from_str::<serde_json::Value>(&content) {
                     Ok(value) => json_to_lua(lua, &value),
                     Err(_) => Ok(Value::Nil),
-                }
+                },
+                Err(_) => Ok(Value::Nil),
             }
-            Err(_) => Ok(Value::Nil),
-        }
-    })?)?;
+        })?,
+    )?;
 
     // owlry.fs.write(path, content) -> bool
-    fs.set("write", lua.create_function(|_, (path, content): (String, String)| {
-        let path = expand_path(&path);
-        // Create parent directories if needed
-        if let Some(parent) = Path::new(&path).parent() {
-            let _ = std::fs::create_dir_all(parent);
-        }
-        Ok(std::fs::write(&path, content).is_ok())
-    })?)?;
+    fs.set(
+        "write",
+        lua.create_function(|_, (path, content): (String, String)| {
+            let path = expand_path(&path);
+            // Create parent directories if needed
+            if let Some(parent) = Path::new(&path).parent() {
+                let _ = std::fs::create_dir_all(parent);
+            }
+            Ok(std::fs::write(&path, content).is_ok())
+        })?,
+    )?;
 
     owlry.set("fs", fs)?;
     Ok(())
@@ -195,18 +246,24 @@ pub fn register_json_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
     let json = lua.create_table()?;
 
     // owlry.json.encode(value) -> string
-    json.set("encode", lua.create_function(|lua, value: Value| {
-        let json_value = lua_to_json(lua, &value)?;
-        Ok(serde_json::to_string(&json_value).unwrap_or_else(|_| "null".to_string()))
-    })?)?;
+    json.set(
+        "encode",
+        lua.create_function(|lua, value: Value| {
+            let json_value = lua_to_json(lua, &value)?;
+            Ok(serde_json::to_string(&json_value).unwrap_or_else(|_| "null".to_string()))
+        })?,
+    )?;
 
     // owlry.json.decode(string) -> value or nil
-    json.set("decode", lua.create_function(|lua, s: String| {
-        match serde_json::from_str::<serde_json::Value>(&s) {
-            Ok(value) => json_to_lua(lua, &value),
-            Err(_) => Ok(Value::Nil),
-        }
-    })?)?;
+    json.set(
+        "decode",
+        lua.create_function(|lua, s: String| {
+            match serde_json::from_str::<serde_json::Value>(&s) {
+                Ok(value) => json_to_lua(lua, &value),
+                Err(_) => Ok(Value::Nil),
+            }
+        })?,
+    )?;
 
     owlry.set("json", json)?;
     Ok(())
@@ -219,9 +276,10 @@ pub fn register_json_api(lua: &Lua, owlry: &Table) -> LuaResult<()> {
 /// Expand ~ in paths
 fn expand_path(path: &str) -> String {
     if path.starts_with("~/")
-        && let Some(home) = dirs::home_dir() {
-            return home.join(&path[2..]).to_string_lossy().to_string();
-        }
+        && let Some(home) = dirs::home_dir()
+    {
+        return home.join(&path[2..]).to_string_lossy().to_string();
+    }
     path.to_string()
 }
 
@@ -305,7 +363,7 @@ fn lua_to_json(_lua: &Lua, value: &Value) -> LuaResult<serde_json::Value> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::runtime::{create_lua_runtime, SandboxConfig};
+    use crate::runtime::{SandboxConfig, create_lua_runtime};
 
     #[test]
     fn test_log_api() {
@@ -316,7 +374,10 @@ mod tests {
         lua.globals().set("owlry", owlry).unwrap();
 
         // Just verify it doesn't panic
-        lua.load("owlry.log.info('test message')").set_name("test").call::<()>(()).unwrap();
+        lua.load("owlry.log.info('test message')")
+            .set_name("test")
+            .call::<()>(())
+            .unwrap();
     }
 
     #[test]
@@ -327,10 +388,18 @@ mod tests {
         register_path_api(&lua, &owlry, Path::new("/tmp/test-plugin")).unwrap();
         lua.globals().set("owlry", owlry).unwrap();
 
-        let home: String = lua.load("return owlry.path.home()").set_name("test").call(()).unwrap();
+        let home: String = lua
+            .load("return owlry.path.home()")
+            .set_name("test")
+            .call(())
+            .unwrap();
         assert!(!home.is_empty());
 
-        let plugin_dir: String = lua.load("return owlry.path.plugin_dir()").set_name("test").call(()).unwrap();
+        let plugin_dir: String = lua
+            .load("return owlry.path.plugin_dir()")
+            .set_name("test")
+            .call(())
+            .unwrap();
         assert_eq!(plugin_dir, "/tmp/test-plugin");
     }
 
@@ -342,10 +411,18 @@ mod tests {
         register_fs_api(&lua, &owlry, Path::new("/tmp")).unwrap();
         lua.globals().set("owlry", owlry).unwrap();
 
-        let exists: bool = lua.load("return owlry.fs.exists('/tmp')").set_name("test").call(()).unwrap();
+        let exists: bool = lua
+            .load("return owlry.fs.exists('/tmp')")
+            .set_name("test")
+            .call(())
+            .unwrap();
         assert!(exists);
 
-        let is_dir: bool = lua.load("return owlry.fs.is_dir('/tmp')").set_name("test").call(()).unwrap();
+        let is_dir: bool = lua
+            .load("return owlry.fs.is_dir('/tmp')")
+            .set_name("test")
+            .call(())
+            .unwrap();
         assert!(is_dir);
     }
 

crates/owlry-lua/src/lib.rs

@@ -27,34 +27,29 @@ mod manifest;
 mod runtime;
 
 use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{PluginItem, ProviderKind};
+use owlry_plugin_api::PluginItem;
 use std::collections::HashMap;
 use std::path::PathBuf;
 
 use loader::LoadedPlugin;
 
-// Runtime metadata
-const RUNTIME_ID: &str = "lua";
-const RUNTIME_NAME: &str = "Lua Runtime";
-const RUNTIME_VERSION: &str = env!("CARGO_PKG_VERSION");
-const RUNTIME_DESCRIPTION: &str = "Lua 5.4 runtime for user plugins";
-
-/// API version for compatibility checking
-pub const LUA_RUNTIME_API_VERSION: u32 = 1;
-
 /// Runtime vtable - exported interface for the core to use
 #[repr(C)]
 pub struct LuaRuntimeVTable {
     /// Get runtime info
     pub info: extern "C" fn() -> RuntimeInfo,
     /// Initialize the runtime with plugins directory
-    pub init: extern "C" fn(plugins_dir: RStr<'_>) -> RuntimeHandle,
+    pub init: extern "C" fn(plugins_dir: RStr<'_>, owlry_version: RStr<'_>) -> RuntimeHandle,
     /// Get provider infos from all loaded plugins
     pub providers: extern "C" fn(handle: RuntimeHandle) -> RVec<LuaProviderInfo>,
     /// Refresh a provider's items
     pub refresh: extern "C" fn(handle: RuntimeHandle, provider_id: RStr<'_>) -> RVec<PluginItem>,
     /// Query a dynamic provider
-    pub query: extern "C" fn(handle: RuntimeHandle, provider_id: RStr<'_>, query: RStr<'_>) -> RVec<PluginItem>,
+    pub query: extern "C" fn(
+        handle: RuntimeHandle,
+        provider_id: RStr<'_>,
+        query: RStr<'_>,
+    ) -> RVec<PluginItem>,
     /// Cleanup and drop the runtime
     pub drop: extern "C" fn(handle: RuntimeHandle),
 }
@@ -62,11 +57,8 @@ pub struct LuaRuntimeVTable {
 /// Runtime info returned by the runtime
 #[repr(C)]
 pub struct RuntimeInfo {
-    pub id: RString,
     pub name: RString,
     pub version: RString,
-    pub description: RString,
-    pub api_version: u32,
 }
 
 /// Opaque handle to the runtime state
@@ -83,11 +75,15 @@ impl RuntimeHandle {
     /// Create a null handle (reserved for error cases)
     #[allow(dead_code)]
     fn null() -> Self {
-        Self { ptr: std::ptr::null_mut() }
+        Self {
+            ptr: std::ptr::null_mut(),
+        }
     }
 
     fn from_box<T>(state: Box<T>) -> Self {
-        Self { ptr: Box::into_raw(state) as *mut () }
+        Self {
+            ptr: Box::into_raw(state) as *mut (),
+        }
     }
 
     unsafe fn drop_as<T>(&self) {
@@ -98,24 +94,22 @@ impl RuntimeHandle {
 }
 
 /// Provider info from a Lua plugin
+///
+/// Must match ScriptProviderInfo layout in owlry-core/src/plugins/runtime_loader.rs
 #[repr(C)]
 pub struct LuaProviderInfo {
-    /// Full provider ID: "plugin_id:provider_name"
-    pub id: RString,
-    /// Plugin ID this provider belongs to
-    pub plugin_id: RString,
-    /// Provider name within the plugin
-    pub provider_name: RString,
+    /// Provider name (used as vtable refresh/query key: "plugin_id:provider_name")
+    pub name: RString,
     /// Display name
     pub display_name: RString,
-    /// Optional prefix trigger
-    pub prefix: ROption<RString>,
-    /// Icon name
-    pub icon: RString,
-    /// Provider type (static/dynamic)
-    pub provider_type: ProviderKind,
     /// Type ID for filtering
     pub type_id: RString,
+    /// Icon name
+    pub default_icon: RString,
+    /// Whether this is a static provider (true) or dynamic (false)
+    pub is_static: bool,
+    /// Optional prefix trigger
+    pub prefix: ROption<RString>,
 }
 
 /// Internal runtime state
@@ -147,7 +141,10 @@ impl LuaRuntimeState {
         for (id, (manifest, path)) in discovered {
             // Check version compatibility
             if !manifest.is_compatible_with(owlry_version) {
-                eprintln!("owlry-lua: Plugin '{}' not compatible with owlry {}", id, owlry_version);
+                eprintln!(
+                    "owlry-lua: Plugin '{}' not compatible with owlry {}",
+                    id, owlry_version
+                );
                 continue;
             }
 
@@ -176,21 +173,14 @@ impl LuaRuntimeState {
             if let Ok(registrations) = plugin.get_provider_registrations() {
                 for reg in registrations {
                     let full_id = format!("{}:{}", plugin_id, reg.name);
-                    let provider_type = if reg.is_dynamic {
-                        ProviderKind::Dynamic
-                    } else {
-                        ProviderKind::Static
-                    };
 
                     providers.push(LuaProviderInfo {
-                        id: RString::from(full_id),
-                        plugin_id: RString::from(plugin_id.as_str()),
-                        provider_name: RString::from(reg.name.as_str()),
+                        name: RString::from(full_id),
                         display_name: RString::from(reg.display_name.as_str()),
-                        prefix: reg.prefix.map(RString::from).into(),
-                        icon: RString::from(reg.default_icon.as_str()),
-                        provider_type,
                         type_id: RString::from(reg.type_id.as_str()),
+                        default_icon: RString::from(reg.default_icon.as_str()),
+                        is_static: !reg.is_dynamic,
+                        prefix: reg.prefix.map(RString::from).into(),
                     });
                 }
             }
@@ -248,22 +238,15 @@ impl LuaRuntimeState {
 
 extern "C" fn runtime_info() -> RuntimeInfo {
     RuntimeInfo {
-        id: RString::from(RUNTIME_ID),
-        name: RString::from(RUNTIME_NAME),
-        version: RString::from(RUNTIME_VERSION),
-        description: RString::from(RUNTIME_DESCRIPTION),
-        api_version: LUA_RUNTIME_API_VERSION,
+        name: RString::from("Lua"),
+        version: RString::from(env!("CARGO_PKG_VERSION")),
     }
 }
 
-extern "C" fn runtime_init(plugins_dir: RStr<'_>) -> RuntimeHandle {
+extern "C" fn runtime_init(plugins_dir: RStr<'_>, owlry_version: RStr<'_>) -> RuntimeHandle {
     let plugins_dir = PathBuf::from(plugins_dir.as_str());
     let mut state = Box::new(LuaRuntimeState::new(plugins_dir));
-
-    // TODO: Get owlry version from core somehow
-    // For now, use a reasonable default
-    state.discover_and_load("0.3.0");
-
+    state.discover_and_load(owlry_version.as_str());
     RuntimeHandle::from_box(state)
 }
 
@@ -285,13 +268,19 @@ extern "C" fn runtime_refresh(handle: RuntimeHandle, provider_id: RStr<'_>) -> R
     state.refresh_provider(provider_id.as_str()).into()
 }
 
-extern "C" fn runtime_query(handle: RuntimeHandle, provider_id: RStr<'_>, query: RStr<'_>) -> RVec<PluginItem> {
+extern "C" fn runtime_query(
+    handle: RuntimeHandle,
+    provider_id: RStr<'_>,
+    query: RStr<'_>,
+) -> RVec<PluginItem> {
     if handle.ptr.is_null() {
         return RVec::new();
     }
 
     let state = unsafe { &*(handle.ptr as *const LuaRuntimeState) };
-    state.query_provider(provider_id.as_str(), query.as_str()).into()
+    state
+        .query_provider(provider_id.as_str(), query.as_str())
+        .into()
 }
 
 extern "C" fn runtime_drop(handle: RuntimeHandle) {
@@ -329,8 +318,8 @@ mod tests {
     #[test]
     fn test_runtime_info() {
         let info = runtime_info();
-        assert_eq!(info.id.as_str(), "lua");
-        assert_eq!(info.api_version, LUA_RUNTIME_API_VERSION);
+        assert_eq!(info.name.as_str(), "Lua");
+        assert!(!info.version.as_str().is_empty());
     }
 
     #[test]

crates/owlry-lua/src/loader.rs

@@ -8,7 +8,7 @@ use owlry_plugin_api::PluginItem;
 
 use crate::api;
 use crate::manifest::PluginManifest;
-use crate::runtime::{create_lua_runtime, load_file, SandboxConfig};
+use crate::runtime::{SandboxConfig, create_lua_runtime, load_file};
 
 /// Provider registration info from Lua
 #[derive(Debug, Clone)]
@@ -77,11 +77,13 @@ impl LoadedPlugin {
         // Load the entry point file
         let entry_path = self.path.join(&self.manifest.plugin.entry);
         if !entry_path.exists() {
-            return Err(format!("Entry point '{}' not found", self.manifest.plugin.entry));
+            return Err(format!(
+                "Entry point '{}' not found",
+                self.manifest.plugin.entry
+            ));
         }
 
-        load_file(&lua, &entry_path)
-            .map_err(|e| format!("Failed to load entry point: {}", e))?;
+        load_file(&lua, &entry_path).map_err(|e| format!("Failed to load entry point: {}", e))?;
 
         self.lua = Some(lua);
         Ok(())
@@ -89,7 +91,9 @@ impl LoadedPlugin {
 
     /// Get provider registrations from this plugin
     pub fn get_provider_registrations(&self) -> Result<Vec<ProviderRegistration>, String> {
-        let lua = self.lua.as_ref()
+        let lua = self
+            .lua
+            .as_ref()
             .ok_or_else(|| "Plugin not initialized".to_string())?;
 
         api::get_provider_registrations(lua)
@@ -98,25 +102,33 @@ impl LoadedPlugin {
 
     /// Call a provider's refresh function
     pub fn call_provider_refresh(&self, provider_name: &str) -> Result<Vec<PluginItem>, String> {
-        let lua = self.lua.as_ref()
+        let lua = self
+            .lua
+            .as_ref()
             .ok_or_else(|| "Plugin not initialized".to_string())?;
 
-        api::call_refresh(lua, provider_name)
-            .map_err(|e| format!("Refresh failed: {}", e))
+        api::call_refresh(lua, provider_name).map_err(|e| format!("Refresh failed: {}", e))
     }
 
     /// Call a provider's query function
-    pub fn call_provider_query(&self, provider_name: &str, query: &str) -> Result<Vec<PluginItem>, String> {
-        let lua = self.lua.as_ref()
+    pub fn call_provider_query(
+        &self,
+        provider_name: &str,
+        query: &str,
+    ) -> Result<Vec<PluginItem>, String> {
+        let lua = self
+            .lua
+            .as_ref()
             .ok_or_else(|| "Plugin not initialized".to_string())?;
 
-        api::call_query(lua, provider_name, query)
-            .map_err(|e| format!("Query failed: {}", e))
+        api::call_query(lua, provider_name, query).map_err(|e| format!("Query failed: {}", e))
     }
 }
 
 /// Discover plugins in a directory
-pub fn discover_plugins(plugins_dir: &Path) -> Result<HashMap<String, (PluginManifest, PathBuf)>, String> {
+pub fn discover_plugins(
+    plugins_dir: &Path,
+) -> Result<HashMap<String, (PluginManifest, PathBuf)>, String> {
     let mut plugins = HashMap::new();
 
     if !plugins_dir.exists() {
@@ -146,13 +158,21 @@ pub fn discover_plugins(plugins_dir: &Path) -> Result<HashMap<String, (PluginMan
             Ok(manifest) => {
                 let id = manifest.plugin.id.clone();
                 if plugins.contains_key(&id) {
-                    eprintln!("owlry-lua: Duplicate plugin ID '{}', skipping {}", id, path.display());
+                    eprintln!(
+                        "owlry-lua: Duplicate plugin ID '{}', skipping {}",
+                        id,
+                        path.display()
+                    );
                     continue;
                 }
                 plugins.insert(id, (manifest, path));
             }
             Err(e) => {
-                eprintln!("owlry-lua: Failed to load plugin at {}: {}", path.display(), e);
+                eprintln!(
+                    "owlry-lua: Failed to load plugin at {}: {}",
+                    path.display(),
+                    e
+                );
             }
         }
     }
@@ -180,7 +200,7 @@ version = "1.0.0"
             id, id
         );
         fs::write(plugin_dir.join("plugin.toml"), manifest).unwrap();
-        fs::write(plugin_dir.join("init.lua"), "-- empty plugin").unwrap();
+        fs::write(plugin_dir.join("main.lua"), "-- empty plugin").unwrap();
     }
 
     #[test]

crates/owlry-lua/src/manifest.rs

@@ -41,7 +41,7 @@ pub struct PluginInfo {
     #[serde(default = "default_owlry_version")]
     pub owlry_version: String,
     /// Entry point file (relative to plugin directory)
-    #[serde(default = "default_entry")]
+    #[serde(default = "default_entry", alias = "entry_point")]
     pub entry: String,
 }
 
@@ -50,7 +50,7 @@ fn default_owlry_version() -> String {
 }
 
 fn default_entry() -> String {
-    "init.lua".to_string()
+    "main.lua".to_string()
 }
 
 /// What the plugin provides
@@ -90,10 +90,10 @@ pub struct PluginPermissions {
 impl PluginManifest {
     /// Load a plugin manifest from a plugin.toml file
     pub fn load(path: &Path) -> Result<Self, String> {
-        let content = std::fs::read_to_string(path)
-            .map_err(|e| format!("Failed to read manifest: {}", e))?;
-        let manifest: PluginManifest = toml::from_str(&content)
-            .map_err(|e| format!("Failed to parse manifest: {}", e))?;
+        let content =
+            std::fs::read_to_string(path).map_err(|e| format!("Failed to read manifest: {}", e))?;
+        let manifest: PluginManifest =
+            toml::from_str(&content).map_err(|e| format!("Failed to parse manifest: {}", e))?;
         manifest.validate()?;
         Ok(manifest)
     }
@@ -105,7 +105,12 @@ impl PluginManifest {
             return Err("Plugin ID cannot be empty".to_string());
         }
 
-        if !self.plugin.id.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-') {
+        if !self
+            .plugin
+            .id
+            .chars()
+            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
+        {
             return Err("Plugin ID must be lowercase alphanumeric with hyphens".to_string());
         }
 
@@ -116,7 +121,10 @@ impl PluginManifest {
 
         // Validate owlry_version constraint
         if semver::VersionReq::parse(&self.plugin.owlry_version).is_err() {
-            return Err(format!("Invalid owlry_version constraint: {}", self.plugin.owlry_version));
+            return Err(format!(
+                "Invalid owlry_version constraint: {}",
+                self.plugin.owlry_version
+            ));
         }
 
         Ok(())
@@ -152,7 +160,7 @@ version = "1.0.0"
         assert_eq!(manifest.plugin.id, "test-plugin");
         assert_eq!(manifest.plugin.name, "Test Plugin");
         assert_eq!(manifest.plugin.version, "1.0.0");
-        assert_eq!(manifest.plugin.entry, "init.lua");
+        assert_eq!(manifest.plugin.entry, "main.lua");
     }
 
     #[test]

crates/owlry-lua/src/runtime.rs

@@ -28,7 +28,7 @@ impl Default for SandboxConfig {
             allow_commands: false,
             allow_network: false,
             allow_external_fs: false,
-            max_run_time_ms: 5000, // 5 seconds
+            max_run_time_ms: 5000,        // 5 seconds
             max_memory: 64 * 1024 * 1024, // 64 MB
         }
     }
@@ -50,11 +50,7 @@ impl SandboxConfig {
 pub fn create_lua_runtime(_sandbox: &SandboxConfig) -> LuaResult<Lua> {
     // Create Lua with safe standard libraries only
     // We exclude: debug, io, os (dangerous parts), package (loadlib), ffi
-    let libs = StdLib::COROUTINE
-        | StdLib::TABLE
-        | StdLib::STRING
-        | StdLib::UTF8
-        | StdLib::MATH;
+    let libs = StdLib::COROUTINE | StdLib::TABLE | StdLib::STRING | StdLib::UTF8 | StdLib::MATH;
 
     let lua = Lua::new_with(libs, mlua::LuaOptions::default())?;
 
@@ -74,11 +70,15 @@ fn setup_safe_globals(lua: &Lua) -> LuaResult<()> {
 
     // Create a restricted os table with only safe functions
     let os_table = lua.create_table()?;
-    os_table.set("clock", lua.create_function(|_, ()| {
-        Ok(std::time::Instant::now().elapsed().as_secs_f64())
-    })?)?;
+    os_table.set(
+        "clock",
+        lua.create_function(|_, ()| Ok(std::time::Instant::now().elapsed().as_secs_f64()))?,
+    )?;
     os_table.set("date", lua.create_function(os_date)?)?;
-    os_table.set("difftime", lua.create_function(|_, (t2, t1): (f64, f64)| Ok(t2 - t1))?)?;
+    os_table.set(
+        "difftime",
+        lua.create_function(|_, (t2, t1): (f64, f64)| Ok(t2 - t1))?,
+    )?;
     os_table.set("time", lua.create_function(os_time)?)?;
     globals.set("os", os_table)?;
 
@@ -107,8 +107,7 @@ fn os_time(_lua: &Lua, _args: ()) -> LuaResult<i64> {
 
 /// Load and run a Lua file in the given runtime
 pub fn load_file(lua: &Lua, path: &std::path::Path) -> LuaResult<()> {
-    let content = std::fs::read_to_string(path)
-        .map_err(mlua::Error::external)?;
+    let content = std::fs::read_to_string(path).map_err(mlua::Error::external)?;
     lua.load(&content)
         .set_name(path.file_name().and_then(|n| n.to_str()).unwrap_or("chunk"))
         .into_function()?

crates/owlry-plugin-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "owlry-plugin-api"
-version = "0.4.9"
+version = "1.0.1"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true

crates/owlry-plugin-api/src/lib.rs

@@ -284,12 +284,8 @@ pub enum NotifyUrgency {
 pub struct HostAPI {
     /// Send a notification to the user
     /// Parameters: summary, body, icon (optional, empty string for none), urgency
-    pub notify: extern "C" fn(
-        summary: RStr<'_>,
-        body: RStr<'_>,
-        icon: RStr<'_>,
-        urgency: NotifyUrgency,
-    ),
+    pub notify:
+        extern "C" fn(summary: RStr<'_>, body: RStr<'_>, icon: RStr<'_>, urgency: NotifyUrgency),
 
     /// Log a message at info level
     pub log_info: extern "C" fn(message: RStr<'_>),
@@ -301,26 +297,24 @@ pub struct HostAPI {
     pub log_error: extern "C" fn(message: RStr<'_>),
 }
 
+use std::sync::OnceLock;
+
 // Global host API pointer - set by the host when loading plugins
-static mut HOST_API: Option<&'static HostAPI> = None;
+static HOST_API: OnceLock<&'static HostAPI> = OnceLock::new();
 
 /// Initialize the host API (called by the host)
 ///
 /// # Safety
 /// Must only be called once by the host before any plugins use the API
 pub unsafe fn init_host_api(api: &'static HostAPI) {
-    // SAFETY: Caller guarantees this is called once before any plugins use the API
-    unsafe {
-        HOST_API = Some(api);
-    }
+    let _ = HOST_API.set(api);
 }
 
 /// Get the host API
 ///
 /// Returns None if the host hasn't initialized the API yet
 pub fn host_api() -> Option<&'static HostAPI> {
-    // SAFETY: We only read the pointer, and it's set once at startup
-    unsafe { HOST_API }
+    HOST_API.get().copied()
 }
 
 // ============================================================================

crates/owlry-plugin-bookmarks/Cargo.toml

@@ -1,31 +0,0 @@
-[package]
-name = "owlry-plugin-bookmarks"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Bookmarks plugin for owlry - browser bookmark search"
-keywords = ["owlry", "plugin", "bookmarks", "browser"]
-categories = ["web-programming"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"
-
-# For finding browser config directories
-dirs = "5.0"
-
-# For parsing Chrome bookmarks JSON
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-
-# For reading Firefox bookmarks (places.sqlite)
-# Use bundled SQLite to avoid system library version conflicts
-rusqlite = { version = "0.32", features = ["bundled"] }

crates/owlry-plugin-bookmarks/src/lib.rs

@@ -1,662 +0,0 @@
-//! Bookmarks Plugin for Owlry
-//!
-//! A static provider that reads browser bookmarks from various browsers.
-//!
-//! Supported browsers:
-//! - Firefox (via places.sqlite using rusqlite with bundled SQLite)
-//! - Chrome
-//! - Chromium
-//! - Brave
-//! - Edge
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-use rusqlite::{Connection, OpenFlags};
-use serde::Deserialize;
-use std::fs;
-use std::io::Write;
-use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use std::thread;
-
-// Plugin metadata
-const PLUGIN_ID: &str = "bookmarks";
-const PLUGIN_NAME: &str = "Bookmarks";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Browser bookmark search";
-
-// Provider metadata
-const PROVIDER_ID: &str = "bookmarks";
-const PROVIDER_NAME: &str = "Bookmarks";
-const PROVIDER_PREFIX: &str = ":bm";
-const PROVIDER_ICON: &str = "user-bookmarks-symbolic";
-const PROVIDER_TYPE_ID: &str = "bookmarks";
-
-/// Bookmarks provider state - holds cached items
-struct BookmarksState {
-    /// Cached bookmark items (returned immediately on refresh)
-    items: Vec<PluginItem>,
-    /// Flag to prevent concurrent background loads
-    loading: Arc<AtomicBool>,
-}
-
-impl BookmarksState {
-    fn new() -> Self {
-        Self {
-            items: Vec::new(),
-            loading: Arc::new(AtomicBool::new(false)),
-        }
-    }
-
-    /// Get or create the favicon cache directory
-    fn favicon_cache_dir() -> Option<PathBuf> {
-        dirs::cache_dir().map(|d| d.join("owlry/favicons"))
-    }
-
-    /// Ensure the favicon cache directory exists
-    fn ensure_favicon_cache_dir() -> Option<PathBuf> {
-        Self::favicon_cache_dir().and_then(|dir| {
-            fs::create_dir_all(&dir).ok()?;
-            Some(dir)
-        })
-    }
-
-    /// Hash a URL to create a cache filename
-    fn url_to_cache_filename(url: &str) -> String {
-        use std::hash::{Hash, Hasher};
-        let mut hasher = std::collections::hash_map::DefaultHasher::new();
-        url.hash(&mut hasher);
-        format!("{:016x}.png", hasher.finish())
-    }
-
-    /// Get the bookmark cache file path
-    fn bookmark_cache_file() -> Option<PathBuf> {
-        dirs::cache_dir().map(|d| d.join("owlry/bookmarks.json"))
-    }
-
-    /// Load cached bookmarks from disk (fast)
-    fn load_cached_bookmarks() -> Vec<PluginItem> {
-        let cache_file = match Self::bookmark_cache_file() {
-            Some(f) => f,
-            None => return Vec::new(),
-        };
-
-        if !cache_file.exists() {
-            return Vec::new();
-        }
-
-        let content = match fs::read_to_string(&cache_file) {
-            Ok(c) => c,
-            Err(_) => return Vec::new(),
-        };
-
-        // Parse cached bookmarks (simple JSON format)
-        #[derive(serde::Deserialize)]
-        struct CachedBookmark {
-            id: String,
-            name: String,
-            command: String,
-            description: Option<String>,
-            icon: String,
-        }
-
-        let cached: Vec<CachedBookmark> = match serde_json::from_str(&content) {
-            Ok(c) => c,
-            Err(_) => return Vec::new(),
-        };
-
-        cached
-            .into_iter()
-            .map(|b| {
-                let mut item = PluginItem::new(b.id, b.name, b.command)
-                    .with_icon(&b.icon)
-                    .with_keywords(vec!["bookmark".to_string()]);
-                if let Some(desc) = b.description {
-                    item = item.with_description(desc);
-                }
-                item
-            })
-            .collect()
-    }
-
-    /// Save bookmarks to cache file
-    fn save_cached_bookmarks(items: &[PluginItem]) {
-        let cache_file = match Self::bookmark_cache_file() {
-            Some(f) => f,
-            None => return,
-        };
-
-        // Ensure cache directory exists
-        if let Some(parent) = cache_file.parent() {
-            let _ = fs::create_dir_all(parent);
-        }
-
-        #[derive(serde::Serialize)]
-        struct CachedBookmark {
-            id: String,
-            name: String,
-            command: String,
-            description: Option<String>,
-            icon: String,
-        }
-
-        let cached: Vec<CachedBookmark> = items
-            .iter()
-            .map(|item| {
-                let desc: Option<String> = match &item.description {
-                    abi_stable::std_types::ROption::RSome(s) => Some(s.to_string()),
-                    abi_stable::std_types::ROption::RNone => None,
-                };
-                let icon: String = match &item.icon {
-                    abi_stable::std_types::ROption::RSome(s) => s.to_string(),
-                    abi_stable::std_types::ROption::RNone => PROVIDER_ICON.to_string(),
-                };
-                CachedBookmark {
-                    id: item.id.to_string(),
-                    name: item.name.to_string(),
-                    command: item.command.to_string(),
-                    description: desc,
-                    icon,
-                }
-            })
-            .collect();
-
-        if let Ok(json) = serde_json::to_string(&cached) {
-            let _ = fs::write(&cache_file, json);
-        }
-    }
-
-    fn chromium_bookmark_paths() -> Vec<PathBuf> {
-        let mut paths = Vec::new();
-
-        if let Some(config_dir) = dirs::config_dir() {
-            // Chrome
-            paths.push(config_dir.join("google-chrome/Default/Bookmarks"));
-            paths.push(config_dir.join("google-chrome-stable/Default/Bookmarks"));
-
-            // Chromium
-            paths.push(config_dir.join("chromium/Default/Bookmarks"));
-
-            // Brave
-            paths.push(config_dir.join("BraveSoftware/Brave-Browser/Default/Bookmarks"));
-
-            // Edge
-            paths.push(config_dir.join("microsoft-edge/Default/Bookmarks"));
-        }
-
-        paths
-    }
-
-    fn firefox_places_paths() -> Vec<PathBuf> {
-        let mut paths = Vec::new();
-
-        if let Some(home) = dirs::home_dir() {
-            let firefox_dir = home.join(".mozilla/firefox");
-            if firefox_dir.exists() {
-                // Find all profile directories
-                if let Ok(entries) = fs::read_dir(&firefox_dir) {
-                    for entry in entries.flatten() {
-                        let path = entry.path();
-                        if path.is_dir() {
-                            let places = path.join("places.sqlite");
-                            if places.exists() {
-                                paths.push(places);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        paths
-    }
-
-    /// Find Firefox favicons.sqlite paths (paired with places.sqlite)
-    fn firefox_favicons_path(places_path: &Path) -> Option<PathBuf> {
-        let favicons = places_path.parent()?.join("favicons.sqlite");
-        if favicons.exists() {
-            Some(favicons)
-        } else {
-            None
-        }
-    }
-
-    fn load_bookmarks(&mut self) {
-        // Fast path: load from cache immediately
-        if self.items.is_empty() {
-            self.items = Self::load_cached_bookmarks();
-        }
-
-        // Don't start another background load if one is already running
-        if self.loading.swap(true, Ordering::SeqCst) {
-            return;
-        }
-
-        // Spawn background thread to refresh bookmarks
-        let loading = self.loading.clone();
-        thread::spawn(move || {
-            let mut items = Vec::new();
-
-            // Load Chrome/Chromium bookmarks (fast - just JSON parsing)
-            for path in Self::chromium_bookmark_paths() {
-                if path.exists() {
-                    Self::read_chrome_bookmarks_static(&path, &mut items);
-                }
-            }
-
-            // Load Firefox bookmarks with favicons (synchronous with rusqlite)
-            for path in Self::firefox_places_paths() {
-                Self::read_firefox_bookmarks(&path, &mut items);
-            }
-
-            // Save to cache for next startup
-            Self::save_cached_bookmarks(&items);
-
-            loading.store(false, Ordering::SeqCst);
-        });
-    }
-
-    /// Read Chrome bookmarks (static helper for background thread)
-    fn read_chrome_bookmarks_static(path: &PathBuf, items: &mut Vec<PluginItem>) {
-        let content = match fs::read_to_string(path) {
-            Ok(c) => c,
-            Err(_) => return,
-        };
-
-        let bookmarks: ChromeBookmarks = match serde_json::from_str(&content) {
-            Ok(b) => b,
-            Err(_) => return,
-        };
-
-        if let Some(roots) = bookmarks.roots {
-            if let Some(bar) = roots.bookmark_bar {
-                Self::process_chrome_folder_static(&bar, items);
-            }
-            if let Some(other) = roots.other {
-                Self::process_chrome_folder_static(&other, items);
-            }
-            if let Some(synced) = roots.synced {
-                Self::process_chrome_folder_static(&synced, items);
-            }
-        }
-    }
-
-    fn process_chrome_folder_static(folder: &ChromeBookmarkNode, items: &mut Vec<PluginItem>) {
-        if let Some(ref children) = folder.children {
-            for child in children {
-                match child.node_type.as_deref() {
-                    Some("url") => {
-                        if let Some(ref url) = child.url {
-                            let name = child.name.clone().unwrap_or_else(|| url.clone());
-                            items.push(
-                                PluginItem::new(
-                                    format!("bookmark:{}", url),
-                                    name,
-                                    format!("xdg-open '{}'", url.replace('\'', "'\\''")),
-                                )
-                                .with_description(url.clone())
-                                .with_icon(PROVIDER_ICON)
-                                .with_keywords(vec!["bookmark".to_string(), "chrome".to_string()]),
-                            );
-                        }
-                    }
-                    Some("folder") => {
-                        Self::process_chrome_folder_static(child, items);
-                    }
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    /// Read Firefox bookmarks using rusqlite (synchronous, bundled SQLite)
-    fn read_firefox_bookmarks(places_path: &PathBuf, items: &mut Vec<PluginItem>) {
-        let temp_dir = std::env::temp_dir();
-        let temp_db = temp_dir.join("owlry_places_temp.sqlite");
-
-        // Copy database to temp location to avoid locking issues
-        if fs::copy(places_path, &temp_db).is_err() {
-            return;
-        }
-
-        // Also copy WAL file if it exists
-        let wal_path = places_path.with_extension("sqlite-wal");
-        if wal_path.exists() {
-            let temp_wal = temp_db.with_extension("sqlite-wal");
-            let _ = fs::copy(&wal_path, &temp_wal);
-        }
-
-        // Copy favicons database if available
-        let favicons_path = Self::firefox_favicons_path(places_path);
-        let temp_favicons = temp_dir.join("owlry_favicons_temp.sqlite");
-        if let Some(ref fp) = favicons_path {
-            let _ = fs::copy(fp, &temp_favicons);
-            let fav_wal = fp.with_extension("sqlite-wal");
-            if fav_wal.exists() {
-                let _ = fs::copy(&fav_wal, temp_favicons.with_extension("sqlite-wal"));
-            }
-        }
-
-        let cache_dir = Self::ensure_favicon_cache_dir();
-
-        // Read bookmarks from places.sqlite
-        let bookmarks = Self::fetch_firefox_bookmarks(&temp_db, &temp_favicons, cache_dir.as_ref());
-
-        // Clean up temp files
-        let _ = fs::remove_file(&temp_db);
-        let _ = fs::remove_file(temp_db.with_extension("sqlite-wal"));
-        let _ = fs::remove_file(&temp_favicons);
-        let _ = fs::remove_file(temp_favicons.with_extension("sqlite-wal"));
-
-        for (title, url, favicon_path) in bookmarks {
-            let icon = favicon_path.unwrap_or_else(|| PROVIDER_ICON.to_string());
-            items.push(
-                PluginItem::new(
-                    format!("bookmark:firefox:{}", url),
-                    title,
-                    format!("xdg-open '{}'", url.replace('\'', "'\\''")),
-                )
-                .with_description(url)
-                .with_icon(&icon)
-                .with_keywords(vec!["bookmark".to_string(), "firefox".to_string()]),
-            );
-        }
-    }
-
-    /// Fetch Firefox bookmarks with optional favicons
-    fn fetch_firefox_bookmarks(
-        places_path: &Path,
-        favicons_path: &Path,
-        cache_dir: Option<&PathBuf>,
-    ) -> Vec<(String, String, Option<String>)> {
-        // Open places.sqlite in read-only mode
-        let conn = match Connection::open_with_flags(
-            places_path,
-            OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
-        ) {
-            Ok(c) => c,
-            Err(_) => return Vec::new(),
-        };
-
-        // Query bookmarks joining moz_bookmarks with moz_places
-        // type=1 means URL bookmarks (not folders, separators, etc.)
-        let query = r#"
-            SELECT b.title, p.url
-            FROM moz_bookmarks b
-            JOIN moz_places p ON b.fk = p.id
-            WHERE b.type = 1
-              AND p.url NOT LIKE 'place:%'
-              AND p.url NOT LIKE 'about:%'
-              AND b.title IS NOT NULL
-              AND b.title != ''
-            ORDER BY b.dateAdded DESC
-            LIMIT 500
-        "#;
-
-        let mut stmt = match conn.prepare(query) {
-            Ok(s) => s,
-            Err(_) => return Vec::new(),
-        };
-
-        let bookmarks: Vec<(String, String)> = stmt
-            .query_map([], |row| {
-                Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
-            })
-            .ok()
-            .map(|rows| rows.filter_map(|r| r.ok()).collect())
-            .unwrap_or_default();
-
-        // If no favicons or cache dir, return without favicons
-        let cache_dir = match cache_dir {
-            Some(c) => c,
-            None => return bookmarks.into_iter().map(|(t, u)| (t, u, None)).collect(),
-        };
-
-        // Try to open favicons database
-        let fav_conn = match Connection::open_with_flags(
-            favicons_path,
-            OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
-        ) {
-            Ok(c) => c,
-            Err(_) => return bookmarks.into_iter().map(|(t, u)| (t, u, None)).collect(),
-        };
-
-        // Fetch favicons for each URL
-        let mut results = Vec::new();
-        for (title, url) in bookmarks {
-            let favicon_path = Self::get_favicon_for_url(&fav_conn, &url, cache_dir);
-            results.push((title, url, favicon_path));
-        }
-
-        results
-    }
-
-    /// Get favicon for a URL, caching to file if needed
-    fn get_favicon_for_url(
-        conn: &Connection,
-        page_url: &str,
-        cache_dir: &Path,
-    ) -> Option<String> {
-        // Check if already cached
-        let cache_filename = Self::url_to_cache_filename(page_url);
-        let cache_path = cache_dir.join(&cache_filename);
-        if cache_path.exists() {
-            return Some(cache_path.to_string_lossy().to_string());
-        }
-
-        // Query favicon data from database
-        // Join moz_pages_w_icons -> moz_icons_to_pages -> moz_icons
-        // Prefer smaller icons (32px) for efficiency
-        let query = r#"
-            SELECT i.data
-            FROM moz_pages_w_icons p
-            JOIN moz_icons_to_pages ip ON p.id = ip.page_id
-            JOIN moz_icons i ON ip.icon_id = i.id
-            WHERE p.page_url = ?
-              AND i.data IS NOT NULL
-            ORDER BY ABS(i.width - 32) ASC
-            LIMIT 1
-        "#;
-
-        let data: Option<Vec<u8>> = conn
-            .query_row(query, [page_url], |row| row.get(0))
-            .ok();
-
-        let data = data?;
-        if data.is_empty() {
-            return None;
-        }
-
-        // Write favicon data to cache file
-        let mut file = fs::File::create(&cache_path).ok()?;
-        file.write_all(&data).ok()?;
-
-        Some(cache_path.to_string_lossy().to_string())
-    }
-}
-
-// Chrome bookmark JSON structures
-#[derive(Debug, Deserialize)]
-struct ChromeBookmarks {
-    roots: Option<ChromeBookmarkRoots>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChromeBookmarkRoots {
-    bookmark_bar: Option<ChromeBookmarkNode>,
-    other: Option<ChromeBookmarkNode>,
-    synced: Option<ChromeBookmarkNode>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ChromeBookmarkNode {
-    name: Option<String>,
-    url: Option<String>,
-    #[serde(rename = "type")]
-    node_type: Option<String>,
-    children: Option<Vec<ChromeBookmarkNode>>,
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 0, // Static: use frecency ordering
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(BookmarksState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<BookmarksState>
-    let state = unsafe { &mut *(handle.ptr as *mut BookmarksState) };
-
-    // Load bookmarks
-    state.load_bookmarks();
-
-    // Return items
-    state.items.to_vec().into()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, _query: RStr<'_>) -> RVec<PluginItem> {
-    // Static provider - query is handled by the core using cached items
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<BookmarksState>
-        unsafe {
-            handle.drop_as::<BookmarksState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_bookmarks_state_new() {
-        let state = BookmarksState::new();
-        assert!(state.items.is_empty());
-    }
-
-    #[test]
-    fn test_chromium_paths() {
-        let paths = BookmarksState::chromium_bookmark_paths();
-        // Should have at least some paths configured
-        assert!(!paths.is_empty());
-    }
-
-    #[test]
-    fn test_firefox_paths() {
-        // This will find paths if Firefox is installed
-        let paths = BookmarksState::firefox_places_paths();
-        // Path detection should work (may be empty if Firefox not installed)
-        let _ = paths.len(); // Just ensure it doesn't panic
-    }
-
-    #[test]
-    fn test_parse_chrome_bookmarks() {
-        let json = r#"{
-            "roots": {
-                "bookmark_bar": {
-                    "type": "folder",
-                    "children": [
-                        {
-                            "type": "url",
-                            "name": "Example",
-                            "url": "https://example.com"
-                        }
-                    ]
-                }
-            }
-        }"#;
-
-        let bookmarks: ChromeBookmarks = serde_json::from_str(json).unwrap();
-        assert!(bookmarks.roots.is_some());
-
-        let roots = bookmarks.roots.unwrap();
-        assert!(roots.bookmark_bar.is_some());
-
-        let bar = roots.bookmark_bar.unwrap();
-        assert!(bar.children.is_some());
-        assert_eq!(bar.children.unwrap().len(), 1);
-    }
-
-    #[test]
-    fn test_process_folder() {
-        let mut items = Vec::new();
-
-        let folder = ChromeBookmarkNode {
-            name: Some("Test Folder".to_string()),
-            url: None,
-            node_type: Some("folder".to_string()),
-            children: Some(vec![
-                ChromeBookmarkNode {
-                    name: Some("Test Bookmark".to_string()),
-                    url: Some("https://test.com".to_string()),
-                    node_type: Some("url".to_string()),
-                    children: None,
-                },
-            ]),
-        };
-
-        BookmarksState::process_chrome_folder_static(&folder, &mut items);
-        assert_eq!(items.len(), 1);
-        assert_eq!(items[0].name.as_str(), "Test Bookmark");
-    }
-
-    #[test]
-    fn test_url_escaping() {
-        let url = "https://example.com/path?query='test'";
-        let command = format!("xdg-open '{}'", url.replace('\'', "'\\''"));
-        assert!(command.contains("'\\''"));
-    }
-}

crates/owlry-plugin-calculator/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "owlry-plugin-calculator"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Calculator plugin for owlry - evaluates mathematical expressions"
-keywords = ["owlry", "plugin", "calculator"]
-categories = ["mathematics"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# Math expression evaluation
-meval = "0.2"
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"

crates/owlry-plugin-calculator/src/lib.rs

@@ -1,231 +0,0 @@
-//! Calculator Plugin for Owlry
-//!
-//! A dynamic provider that evaluates mathematical expressions.
-//! Supports queries prefixed with `=` or `calc `.
-//!
-//! Examples:
-//! - `= 5 + 3` → 8
-//! - `calc sqrt(16)` → 4
-//! - `= pi * 2` → 6.283185...
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-
-// Plugin metadata
-const PLUGIN_ID: &str = "calculator";
-const PLUGIN_NAME: &str = "Calculator";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Evaluate mathematical expressions";
-
-// Provider metadata
-const PROVIDER_ID: &str = "calculator";
-const PROVIDER_NAME: &str = "Calculator";
-const PROVIDER_PREFIX: &str = "=";
-const PROVIDER_ICON: &str = "accessories-calculator";
-const PROVIDER_TYPE_ID: &str = "calc";
-
-/// Calculator provider state (empty for now, but could cache results)
-struct CalculatorState;
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Dynamic,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 10000, // Dynamic: calculator results first
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    // Create state and return handle
-    let state = Box::new(CalculatorState);
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(_handle: ProviderHandle) -> RVec<PluginItem> {
-    // Dynamic provider - refresh does nothing
-    RVec::new()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, query: RStr<'_>) -> RVec<PluginItem> {
-    let query_str = query.as_str();
-
-    // Extract expression from query
-    let expr = match extract_expression(query_str) {
-        Some(e) if !e.is_empty() => e,
-        _ => return RVec::new(),
-    };
-
-    // Evaluate the expression
-    match evaluate_expression(expr) {
-        Some(item) => vec![item].into(),
-        None => RVec::new(),
-    }
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<CalculatorState>
-        unsafe {
-            handle.drop_as::<CalculatorState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Calculator Logic
-// ============================================================================
-
-/// Extract expression from query (handles `= expr` and `calc expr` formats)
-fn extract_expression(query: &str) -> Option<&str> {
-    let trimmed = query.trim();
-
-    // Support both "= expr" and "=expr" (with or without space)
-    if let Some(expr) = trimmed.strip_prefix("= ") {
-        Some(expr.trim())
-    } else if let Some(expr) = trimmed.strip_prefix('=') {
-        Some(expr.trim())
-    } else if let Some(expr) = trimmed.strip_prefix("calc ") {
-        Some(expr.trim())
-    } else {
-        // For filter mode - accept raw expressions
-        Some(trimmed)
-    }
-}
-
-/// Evaluate a mathematical expression and return a PluginItem
-fn evaluate_expression(expr: &str) -> Option<PluginItem> {
-    match meval::eval_str(expr) {
-        Ok(result) => {
-            // Format result nicely
-            let result_str = format_result(result);
-
-            Some(
-                PluginItem::new(
-                    format!("calc:{}", expr),
-                    result_str.clone(),
-                    format!("sh -c 'echo -n \"{}\" | wl-copy'", result_str),
-                )
-                .with_description(format!("= {}", expr))
-                .with_icon(PROVIDER_ICON)
-                .with_keywords(vec!["math".to_string(), "calculator".to_string()]),
-            )
-        }
-        Err(_) => None,
-    }
-}
-
-/// Format a numeric result nicely
-fn format_result(result: f64) -> String {
-    if result.fract() == 0.0 && result.abs() < 1e15 {
-        // Integer result
-        format!("{}", result as i64)
-    } else {
-        // Float result with reasonable precision, trimming trailing zeros
-        let formatted = format!("{:.10}", result);
-        formatted
-            .trim_end_matches('0')
-            .trim_end_matches('.')
-            .to_string()
-    }
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_extract_expression() {
-        assert_eq!(extract_expression("= 5+3"), Some("5+3"));
-        assert_eq!(extract_expression("=5+3"), Some("5+3"));
-        assert_eq!(extract_expression("calc 5+3"), Some("5+3"));
-        assert_eq!(extract_expression("  = 5 + 3 "), Some("5 + 3"));
-        assert_eq!(extract_expression("5+3"), Some("5+3")); // Raw expression
-    }
-
-    #[test]
-    fn test_format_result() {
-        assert_eq!(format_result(8.0), "8");
-        assert_eq!(format_result(2.5), "2.5");
-        assert_eq!(format_result(3.14159265358979), "3.1415926536");
-    }
-
-    #[test]
-    fn test_evaluate_basic() {
-        let item = evaluate_expression("5+3").unwrap();
-        assert_eq!(item.name.as_str(), "8");
-
-        let item = evaluate_expression("10 * 2").unwrap();
-        assert_eq!(item.name.as_str(), "20");
-
-        let item = evaluate_expression("15 / 3").unwrap();
-        assert_eq!(item.name.as_str(), "5");
-    }
-
-    #[test]
-    fn test_evaluate_float() {
-        let item = evaluate_expression("5/2").unwrap();
-        assert_eq!(item.name.as_str(), "2.5");
-    }
-
-    #[test]
-    fn test_evaluate_functions() {
-        let item = evaluate_expression("sqrt(16)").unwrap();
-        assert_eq!(item.name.as_str(), "4");
-
-        let item = evaluate_expression("abs(-5)").unwrap();
-        assert_eq!(item.name.as_str(), "5");
-    }
-
-    #[test]
-    fn test_evaluate_constants() {
-        let item = evaluate_expression("pi").unwrap();
-        assert!(item.name.as_str().starts_with("3.14159"));
-
-        let item = evaluate_expression("e").unwrap();
-        assert!(item.name.as_str().starts_with("2.718"));
-    }
-
-    #[test]
-    fn test_evaluate_invalid() {
-        assert!(evaluate_expression("").is_none());
-        assert!(evaluate_expression("invalid").is_none());
-        assert!(evaluate_expression("5 +").is_none());
-    }
-}

crates/owlry-plugin-clipboard/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "owlry-plugin-clipboard"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Clipboard plugin for owlry - clipboard history via cliphist"
-keywords = ["owlry", "plugin", "clipboard"]
-categories = ["os"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"

crates/owlry-plugin-clipboard/src/lib.rs

@@ -1,259 +0,0 @@
-//! Clipboard Plugin for Owlry
-//!
-//! A static provider that integrates with cliphist to show clipboard history.
-//! Requires cliphist and wl-clipboard to be installed.
-//!
-//! Dependencies:
-//! - cliphist: clipboard history manager
-//! - wl-clipboard: Wayland clipboard utilities (wl-copy)
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-use std::process::Command;
-
-// Plugin metadata
-const PLUGIN_ID: &str = "clipboard";
-const PLUGIN_NAME: &str = "Clipboard";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Clipboard history via cliphist";
-
-// Provider metadata
-const PROVIDER_ID: &str = "clipboard";
-const PROVIDER_NAME: &str = "Clipboard";
-const PROVIDER_PREFIX: &str = ":clip";
-const PROVIDER_ICON: &str = "edit-paste";
-const PROVIDER_TYPE_ID: &str = "clipboard";
-
-// Default max entries to show
-const DEFAULT_MAX_ENTRIES: usize = 50;
-
-/// Clipboard provider state - holds cached items
-struct ClipboardState {
-    items: Vec<PluginItem>,
-    max_entries: usize,
-}
-
-impl ClipboardState {
-    fn new() -> Self {
-        Self {
-            items: Vec::new(),
-            max_entries: DEFAULT_MAX_ENTRIES,
-        }
-    }
-
-    /// Check if cliphist is available
-    fn has_cliphist() -> bool {
-        Command::new("which")
-            .arg("cliphist")
-            .output()
-            .map(|o| o.status.success())
-            .unwrap_or(false)
-    }
-
-    fn load_clipboard_history(&mut self) {
-        self.items.clear();
-
-        if !Self::has_cliphist() {
-            return;
-        }
-
-        // Get clipboard history from cliphist
-        let output = match Command::new("cliphist").arg("list").output() {
-            Ok(o) => o,
-            Err(_) => return,
-        };
-
-        if !output.status.success() {
-            return;
-        }
-
-        let content = String::from_utf8_lossy(&output.stdout);
-
-        for (idx, line) in content.lines().take(self.max_entries).enumerate() {
-            // cliphist format: "id\tpreview"
-            let parts: Vec<&str> = line.splitn(2, '\t').collect();
-
-            if parts.is_empty() {
-                continue;
-            }
-
-            let clip_id = parts[0];
-            let preview = if parts.len() > 1 {
-                // Truncate long previews (char-safe for UTF-8)
-                let p = parts[1];
-                if p.chars().count() > 80 {
-                    let truncated: String = p.chars().take(77).collect();
-                    format!("{}...", truncated)
-                } else {
-                    p.to_string()
-                }
-            } else {
-                "[binary data]".to_string()
-            };
-
-            // Clean up preview - replace newlines with spaces
-            let preview_clean = preview
-                .replace('\n', " ")
-                .replace('\r', "")
-                .replace('\t', " ");
-
-            // Command to paste this entry
-            // echo "id" | cliphist decode | wl-copy
-            let command = format!(
-                "echo '{}' | cliphist decode | wl-copy",
-                clip_id.replace('\'', "'\\''")
-            );
-
-            self.items.push(
-                PluginItem::new(format!("clipboard:{}", idx), preview_clean, command)
-                    .with_description("Copy to clipboard")
-                    .with_icon(PROVIDER_ICON),
-            );
-        }
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 0, // Static: use frecency ordering
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(ClipboardState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<ClipboardState>
-    let state = unsafe { &mut *(handle.ptr as *mut ClipboardState) };
-
-    // Load clipboard history
-    state.load_clipboard_history();
-
-    // Return items
-    state.items.to_vec().into()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, _query: RStr<'_>) -> RVec<PluginItem> {
-    // Static provider - query is handled by the core using cached items
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<ClipboardState>
-        unsafe {
-            handle.drop_as::<ClipboardState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_clipboard_state_new() {
-        let state = ClipboardState::new();
-        assert!(state.items.is_empty());
-        assert_eq!(state.max_entries, DEFAULT_MAX_ENTRIES);
-    }
-
-    #[test]
-    fn test_preview_truncation() {
-        // Test that long strings would be truncated (char-safe)
-        let long_text = "a".repeat(100);
-        let truncated = if long_text.chars().count() > 80 {
-            let t: String = long_text.chars().take(77).collect();
-            format!("{}...", t)
-        } else {
-            long_text.clone()
-        };
-        assert_eq!(truncated.chars().count(), 80);
-        assert!(truncated.ends_with("..."));
-    }
-
-    #[test]
-    fn test_preview_truncation_utf8() {
-        // Test with multi-byte UTF-8 characters (box-drawing chars are 3 bytes each)
-        let utf8_text = "├── ".repeat(30); // Each "├── " is 7 bytes but 4 chars
-        let truncated = if utf8_text.chars().count() > 80 {
-            let t: String = utf8_text.chars().take(77).collect();
-            format!("{}...", t)
-        } else {
-            utf8_text.clone()
-        };
-        assert_eq!(truncated.chars().count(), 80);
-        assert!(truncated.ends_with("..."));
-    }
-
-    #[test]
-    fn test_preview_cleaning() {
-        let dirty = "line1\nline2\tcolumn\rend";
-        let clean = dirty
-            .replace('\n', " ")
-            .replace('\r', "")
-            .replace('\t', " ");
-        assert_eq!(clean, "line1 line2 columnend");
-    }
-
-    #[test]
-    fn test_command_escaping() {
-        let clip_id = "test'id";
-        let command = format!(
-            "echo '{}' | cliphist decode | wl-copy",
-            clip_id.replace('\'', "'\\''")
-        );
-        assert!(command.contains("test'\\''id"));
-    }
-
-    #[test]
-    fn test_has_cliphist_runs() {
-        // Just ensure it doesn't panic - cliphist may or may not be installed
-        let _ = ClipboardState::has_cliphist();
-    }
-}

crates/owlry-plugin-emoji/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "owlry-plugin-emoji"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Emoji plugin for owlry - search and copy emojis"
-keywords = ["owlry", "plugin", "emoji"]
-categories = ["text-processing"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"

crates/owlry-plugin-emoji/src/lib.rs

@@ -1,565 +0,0 @@
-//! Emoji Plugin for Owlry
-//!
-//! A static provider that provides emoji search and copy functionality.
-//! Requires wl-clipboard (wl-copy) for copying to clipboard.
-//!
-//! Examples:
-//! - Search "smile" → 😀 😃 😄 etc.
-//! - Search "heart" → ❤️ 💙 💚 etc.
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-
-// Plugin metadata
-const PLUGIN_ID: &str = "emoji";
-const PLUGIN_NAME: &str = "Emoji";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Search and copy emojis";
-
-// Provider metadata
-const PROVIDER_ID: &str = "emoji";
-const PROVIDER_NAME: &str = "Emoji";
-const PROVIDER_PREFIX: &str = ":emoji";
-const PROVIDER_ICON: &str = "face-smile";
-const PROVIDER_TYPE_ID: &str = "emoji";
-
-/// Emoji provider state - holds cached items
-struct EmojiState {
-    items: Vec<PluginItem>,
-}
-
-impl EmojiState {
-    fn new() -> Self {
-        Self { items: Vec::new() }
-    }
-
-    fn load_emojis(&mut self) {
-        self.items.clear();
-
-        // Common emojis with searchable names
-        // Format: (emoji, name, keywords)
-        let emojis: &[(&str, &str, &str)] = &[
-            // Smileys & Emotion
-            ("😀", "grinning face", "smile happy"),
-            ("😃", "grinning face with big eyes", "smile happy"),
-            ("😄", "grinning face with smiling eyes", "smile happy laugh"),
-            ("😁", "beaming face with smiling eyes", "smile happy grin"),
-            ("😅", "grinning face with sweat", "smile nervous"),
-            ("🤣", "rolling on the floor laughing", "lol rofl funny"),
-            ("😂", "face with tears of joy", "laugh cry funny lol"),
-            ("🙂", "slightly smiling face", "smile"),
-            ("😊", "smiling face with smiling eyes", "blush happy"),
-            ("😇", "smiling face with halo", "angel innocent"),
-            ("🥰", "smiling face with hearts", "love adore"),
-            ("😍", "smiling face with heart-eyes", "love crush"),
-            ("🤩", "star-struck", "excited wow amazing"),
-            ("😘", "face blowing a kiss", "kiss love"),
-            ("😜", "winking face with tongue", "playful silly"),
-            ("🤪", "zany face", "crazy silly wild"),
-            ("😎", "smiling face with sunglasses", "cool"),
-            ("🤓", "nerd face", "geek glasses"),
-            ("🧐", "face with monocle", "thinking inspect"),
-            ("😏", "smirking face", "smug"),
-            ("😒", "unamused face", "meh annoyed"),
-            ("🙄", "face with rolling eyes", "whatever annoyed"),
-            ("😬", "grimacing face", "awkward nervous"),
-            ("😮‍💨", "face exhaling", "sigh relief"),
-            ("🤥", "lying face", "pinocchio lie"),
-            ("😌", "relieved face", "relaxed peaceful"),
-            ("😔", "pensive face", "sad thoughtful"),
-            ("😪", "sleepy face", "tired"),
-            ("🤤", "drooling face", "hungry yummy"),
-            ("😴", "sleeping face", "zzz tired"),
-            ("😷", "face with medical mask", "sick covid"),
-            ("🤒", "face with thermometer", "sick fever"),
-            ("🤕", "face with head-bandage", "hurt injured"),
-            ("🤢", "nauseated face", "sick gross"),
-            ("🤮", "face vomiting", "sick puke"),
-            ("🤧", "sneezing face", "achoo sick"),
-            ("🥵", "hot face", "sweating heat"),
-            ("🥶", "cold face", "freezing"),
-            ("😵", "face with crossed-out eyes", "dizzy dead"),
-            ("🤯", "exploding head", "mind blown wow"),
-            ("🤠", "cowboy hat face", "yeehaw western"),
-            ("🥳", "partying face", "celebration party"),
-            ("🥸", "disguised face", "incognito"),
-            ("🤡", "clown face", "circus"),
-            ("👻", "ghost", "halloween spooky"),
-            ("💀", "skull", "dead death"),
-            ("☠️", "skull and crossbones", "danger death"),
-            ("👽", "alien", "ufo extraterrestrial"),
-            ("🤖", "robot", "bot android"),
-            ("💩", "pile of poo", "poop"),
-            ("😈", "smiling face with horns", "devil evil"),
-            ("👿", "angry face with horns", "devil evil"),
-            // Gestures & People
-            ("👋", "waving hand", "hello hi bye wave"),
-            ("🤚", "raised back of hand", "stop"),
-            ("🖐️", "hand with fingers splayed", "five high"),
-            ("✋", "raised hand", "stop high five"),
-            ("🖖", "vulcan salute", "spock trek"),
-            ("👌", "ok hand", "okay perfect"),
-            ("🤌", "pinched fingers", "italian"),
-            ("🤏", "pinching hand", "small tiny"),
-            ("✌️", "victory hand", "peace two"),
-            ("🤞", "crossed fingers", "luck hope"),
-            ("🤟", "love-you gesture", "ily rock"),
-            ("🤘", "sign of the horns", "rock metal"),
-            ("🤙", "call me hand", "shaka hang loose"),
-            ("👈", "backhand index pointing left", "left point"),
-            ("👉", "backhand index pointing right", "right point"),
-            ("👆", "backhand index pointing up", "up point"),
-            ("👇", "backhand index pointing down", "down point"),
-            ("☝️", "index pointing up", "one point"),
-            ("👍", "thumbs up", "like yes good approve"),
-            ("👎", "thumbs down", "dislike no bad"),
-            ("✊", "raised fist", "power solidarity"),
-            ("👊", "oncoming fist", "punch bump"),
-            ("🤛", "left-facing fist", "fist bump"),
-            ("🤜", "right-facing fist", "fist bump"),
-            ("👏", "clapping hands", "applause bravo"),
-            ("🙌", "raising hands", "hooray celebrate"),
-            ("👐", "open hands", "hug"),
-            ("🤲", "palms up together", "prayer"),
-            ("🤝", "handshake", "agreement deal"),
-            ("🙏", "folded hands", "prayer please thanks"),
-            ("✍️", "writing hand", "write"),
-            ("💪", "flexed biceps", "strong muscle"),
-            ("🦾", "mechanical arm", "robot prosthetic"),
-            ("🦵", "leg", "kick"),
-            ("🦶", "foot", "kick"),
-            ("👂", "ear", "listen hear"),
-            ("👃", "nose", "smell"),
-            ("🧠", "brain", "smart think"),
-            ("👀", "eyes", "look see watch"),
-            ("👁️", "eye", "see look"),
-            ("👅", "tongue", "taste lick"),
-            ("👄", "mouth", "lips kiss"),
-            // Hearts & Love
-            ("❤️", "red heart", "love"),
-            ("🧡", "orange heart", "love"),
-            ("💛", "yellow heart", "love friendship"),
-            ("💚", "green heart", "love"),
-            ("💙", "blue heart", "love"),
-            ("💜", "purple heart", "love"),
-            ("🖤", "black heart", "love dark"),
-            ("🤍", "white heart", "love pure"),
-            ("🤎", "brown heart", "love"),
-            ("💔", "broken heart", "heartbreak sad"),
-            ("❤️‍🔥", "heart on fire", "passion love"),
-            ("❤️‍🩹", "mending heart", "healing recovery"),
-            ("💕", "two hearts", "love"),
-            ("💞", "revolving hearts", "love"),
-            ("💓", "beating heart", "love"),
-            ("💗", "growing heart", "love"),
-            ("💖", "sparkling heart", "love"),
-            ("💘", "heart with arrow", "love cupid"),
-            ("💝", "heart with ribbon", "love gift"),
-            ("💟", "heart decoration", "love"),
-            // Animals
-            ("🐶", "dog face", "puppy"),
-            ("🐱", "cat face", "kitty"),
-            ("🐭", "mouse face", ""),
-            ("🐹", "hamster", ""),
-            ("🐰", "rabbit face", "bunny"),
-            ("🦊", "fox", ""),
-            ("🐻", "bear", ""),
-            ("🐼", "panda", ""),
-            ("🐨", "koala", ""),
-            ("🐯", "tiger face", ""),
-            ("🦁", "lion", ""),
-            ("🐮", "cow face", ""),
-            ("🐷", "pig face", ""),
-            ("🐸", "frog", ""),
-            ("🐵", "monkey face", ""),
-            ("🦄", "unicorn", "magic"),
-            ("🐝", "bee", "honeybee"),
-            ("🦋", "butterfly", ""),
-            ("🐌", "snail", "slow"),
-            ("🐛", "bug", "caterpillar"),
-            ("🦀", "crab", ""),
-            ("🐙", "octopus", ""),
-            ("🐠", "tropical fish", ""),
-            ("🐟", "fish", ""),
-            ("🐬", "dolphin", ""),
-            ("🐳", "whale", ""),
-            ("🦈", "shark", ""),
-            ("🐊", "crocodile", "alligator"),
-            ("🐢", "turtle", ""),
-            ("🦎", "lizard", ""),
-            ("🐍", "snake", ""),
-            ("🦖", "t-rex", "dinosaur"),
-            ("🦕", "sauropod", "dinosaur"),
-            ("🐔", "chicken", ""),
-            ("🐧", "penguin", ""),
-            ("🦅", "eagle", "bird"),
-            ("🦆", "duck", ""),
-            ("🦉", "owl", ""),
-            // Food & Drink
-            ("🍎", "red apple", "fruit"),
-            ("🍐", "pear", "fruit"),
-            ("🍊", "orange", "tangerine fruit"),
-            ("🍋", "lemon", "fruit"),
-            ("🍌", "banana", "fruit"),
-            ("🍉", "watermelon", "fruit"),
-            ("🍇", "grapes", "fruit"),
-            ("🍓", "strawberry", "fruit"),
-            ("🍒", "cherries", "fruit"),
-            ("🍑", "peach", "fruit"),
-            ("🥭", "mango", "fruit"),
-            ("🍍", "pineapple", "fruit"),
-            ("🥥", "coconut", "fruit"),
-            ("🥝", "kiwi", "fruit"),
-            ("🍅", "tomato", "vegetable"),
-            ("🥑", "avocado", ""),
-            ("🥦", "broccoli", "vegetable"),
-            ("🥬", "leafy green", "vegetable salad"),
-            ("🥒", "cucumber", "vegetable"),
-            ("🌶️", "hot pepper", "spicy chili"),
-            ("🌽", "corn", ""),
-            ("🥕", "carrot", "vegetable"),
-            ("🧄", "garlic", ""),
-            ("🧅", "onion", ""),
-            ("🥔", "potato", ""),
-            ("🍞", "bread", ""),
-            ("🥐", "croissant", ""),
-            ("🥖", "baguette", "bread french"),
-            ("🥨", "pretzel", ""),
-            ("🧀", "cheese", ""),
-            ("🥚", "egg", ""),
-            ("🍳", "cooking", "frying pan egg"),
-            ("🥞", "pancakes", "breakfast"),
-            ("🧇", "waffle", "breakfast"),
-            ("🥓", "bacon", "breakfast"),
-            ("🍔", "hamburger", "burger"),
-            ("🍟", "french fries", ""),
-            ("🍕", "pizza", ""),
-            ("🌭", "hot dog", ""),
-            ("🥪", "sandwich", ""),
-            ("🌮", "taco", "mexican"),
-            ("🌯", "burrito", "mexican"),
-            ("🍜", "steaming bowl", "ramen noodles"),
-            ("🍝", "spaghetti", "pasta"),
-            ("🍣", "sushi", "japanese"),
-            ("🍱", "bento box", "japanese"),
-            ("🍩", "doughnut", "donut dessert"),
-            ("🍪", "cookie", "dessert"),
-            ("🎂", "birthday cake", "dessert"),
-            ("🍰", "shortcake", "dessert"),
-            ("🧁", "cupcake", "dessert"),
-            ("🍫", "chocolate bar", "dessert"),
-            ("🍬", "candy", "sweet"),
-            ("🍭", "lollipop", "candy sweet"),
-            ("🍦", "soft ice cream", "dessert"),
-            ("🍨", "ice cream", "dessert"),
-            ("☕", "hot beverage", "coffee tea"),
-            ("🍵", "teacup", "tea"),
-            ("🧃", "juice box", ""),
-            ("🥤", "cup with straw", "soda drink"),
-            ("🍺", "beer mug", "drink alcohol"),
-            ("🍻", "clinking beer mugs", "cheers drink"),
-            ("🥂", "clinking glasses", "champagne cheers"),
-            ("🍷", "wine glass", "drink alcohol"),
-            ("🥃", "tumbler glass", "whiskey drink"),
-            ("🍸", "cocktail glass", "martini drink"),
-            // Objects & Symbols
-            ("💻", "laptop", "computer"),
-            ("🖥️", "desktop computer", "pc"),
-            ("⌨️", "keyboard", ""),
-            ("🖱️", "computer mouse", ""),
-            ("💾", "floppy disk", "save"),
-            ("💿", "optical disk", "cd"),
-            ("📱", "mobile phone", "smartphone"),
-            ("☎️", "telephone", "phone"),
-            ("📧", "email", "mail"),
-            ("📨", "incoming envelope", "email"),
-            ("📩", "envelope with arrow", "email send"),
-            ("📝", "memo", "note write"),
-            ("📄", "page facing up", "document"),
-            ("📃", "page with curl", "document"),
-            ("📑", "bookmark tabs", ""),
-            ("📚", "books", "library read"),
-            ("📖", "open book", "read"),
-            ("🔗", "link", "chain url"),
-            ("📎", "paperclip", "attachment"),
-            ("🔒", "locked", "security"),
-            ("🔓", "unlocked", "security open"),
-            ("🔑", "key", "password"),
-            ("🔧", "wrench", "tool fix"),
-            ("🔨", "hammer", "tool"),
-            ("⚙️", "gear", "settings"),
-            ("🧲", "magnet", ""),
-            ("💡", "light bulb", "idea"),
-            ("🔦", "flashlight", ""),
-            ("🔋", "battery", "power"),
-            ("🔌", "electric plug", "power"),
-            ("💰", "money bag", ""),
-            ("💵", "dollar", "money cash"),
-            ("💳", "credit card", "payment"),
-            ("⏰", "alarm clock", "time"),
-            ("⏱️", "stopwatch", "timer"),
-            ("📅", "calendar", "date"),
-            ("📆", "tear-off calendar", "date"),
-            ("✅", "check mark", "done yes"),
-            ("❌", "cross mark", "no wrong delete"),
-            ("❓", "question mark", "help"),
-            ("❗", "exclamation mark", "important warning"),
-            ("⚠️", "warning", "caution alert"),
-            ("🚫", "prohibited", "no ban forbidden"),
-            ("⭕", "hollow circle", ""),
-            ("🔴", "red circle", ""),
-            ("🟠", "orange circle", ""),
-            ("🟡", "yellow circle", ""),
-            ("🟢", "green circle", ""),
-            ("🔵", "blue circle", ""),
-            ("🟣", "purple circle", ""),
-            ("⚫", "black circle", ""),
-            ("⚪", "white circle", ""),
-            ("🟤", "brown circle", ""),
-            ("⬛", "black square", ""),
-            ("⬜", "white square", ""),
-            ("🔶", "large orange diamond", ""),
-            ("🔷", "large blue diamond", ""),
-            ("⭐", "star", "favorite"),
-            ("🌟", "glowing star", "sparkle"),
-            ("✨", "sparkles", "magic shine"),
-            ("💫", "dizzy", "star"),
-            ("🔥", "fire", "hot lit"),
-            ("💧", "droplet", "water"),
-            ("🌊", "wave", "water ocean"),
-            ("🎵", "musical note", "music"),
-            ("🎶", "musical notes", "music"),
-            ("🎤", "microphone", "sing karaoke"),
-            ("🎧", "headphones", "music"),
-            ("🎮", "video game", "gaming controller"),
-            ("🕹️", "joystick", "gaming"),
-            ("🎯", "direct hit", "target bullseye"),
-            ("🏆", "trophy", "winner award"),
-            ("🥇", "1st place medal", "gold winner"),
-            ("🥈", "2nd place medal", "silver"),
-            ("🥉", "3rd place medal", "bronze"),
-            ("🎁", "wrapped gift", "present"),
-            ("🎈", "balloon", "party"),
-            ("🎉", "party popper", "celebration tada"),
-            ("🎊", "confetti ball", "celebration"),
-            // Arrows & Misc
-            ("➡️", "right arrow", ""),
-            ("⬅️", "left arrow", ""),
-            ("⬆️", "up arrow", ""),
-            ("⬇️", "down arrow", ""),
-            ("↗️", "up-right arrow", ""),
-            ("↘️", "down-right arrow", ""),
-            ("↙️", "down-left arrow", ""),
-            ("↖️", "up-left arrow", ""),
-            ("↕️", "up-down arrow", ""),
-            ("↔️", "left-right arrow", ""),
-            ("🔄", "counterclockwise arrows", "refresh reload"),
-            ("🔃", "clockwise arrows", "refresh reload"),
-            ("➕", "plus", "add"),
-            ("➖", "minus", "subtract"),
-            ("➗", "division", "divide"),
-            ("✖️", "multiply", "times"),
-            ("♾️", "infinity", "forever"),
-            ("💯", "hundred points", "100 perfect"),
-            ("🆗", "ok button", "okay"),
-            ("🆕", "new button", ""),
-            ("🆓", "free button", ""),
-            ("ℹ️", "information", "info"),
-            ("🅿️", "parking", ""),
-            ("🚀", "rocket", "launch startup"),
-            ("✈️", "airplane", "travel flight"),
-            ("🚗", "car", "automobile"),
-            ("🚕", "taxi", "cab"),
-            ("🚌", "bus", ""),
-            ("🚂", "locomotive", "train"),
-            ("🏠", "house", "home"),
-            ("🏢", "office building", "work"),
-            ("🏥", "hospital", ""),
-            ("🏫", "school", ""),
-            ("🏛️", "classical building", ""),
-            ("⛪", "church", ""),
-            ("🕌", "mosque", ""),
-            ("🕍", "synagogue", ""),
-            ("🗽", "statue of liberty", "usa america"),
-            ("🗼", "tokyo tower", "japan"),
-            ("🗾", "map of japan", ""),
-            ("🌍", "globe europe-africa", "earth world"),
-            ("🌎", "globe americas", "earth world"),
-            ("🌏", "globe asia-australia", "earth world"),
-            ("🌑", "new moon", ""),
-            ("🌕", "full moon", ""),
-            ("☀️", "sun", "sunny"),
-            ("🌙", "crescent moon", "night"),
-            ("☁️", "cloud", ""),
-            ("🌧️", "cloud with rain", "rainy"),
-            ("⛈️", "cloud with lightning", "storm thunder"),
-            ("🌈", "rainbow", ""),
-            ("❄️", "snowflake", "cold winter"),
-            ("☃️", "snowman", "winter"),
-            ("🎄", "christmas tree", "xmas holiday"),
-            ("🎃", "jack-o-lantern", "halloween pumpkin"),
-            ("🐚", "shell", "beach"),
-            ("🌸", "cherry blossom", "flower spring"),
-            ("🌺", "hibiscus", "flower"),
-            ("🌻", "sunflower", "flower"),
-            ("🌹", "rose", "flower love"),
-            ("🌷", "tulip", "flower"),
-            ("🌱", "seedling", "plant grow"),
-            ("🌲", "evergreen tree", ""),
-            ("🌳", "deciduous tree", ""),
-            ("🌴", "palm tree", "tropical"),
-            ("🌵", "cactus", "desert"),
-            ("🍀", "four leaf clover", "luck irish"),
-            ("🍁", "maple leaf", "fall autumn canada"),
-            ("🍂", "fallen leaf", "fall autumn"),
-        ];
-
-        for (emoji, name, keywords) in emojis {
-            self.items.push(
-                PluginItem::new(
-                    format!("emoji:{}", emoji),
-                    name.to_string(),
-                    format!("printf '%s' '{}' | wl-copy", emoji),
-                )
-                .with_icon(*emoji) // Use emoji character as icon
-                .with_description(format!("{} {}", emoji, keywords))
-                .with_keywords(vec![name.to_string(), keywords.to_string()]),
-            );
-        }
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 0, // Static: use frecency ordering
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(EmojiState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<EmojiState>
-    let state = unsafe { &mut *(handle.ptr as *mut EmojiState) };
-
-    // Load emojis
-    state.load_emojis();
-
-    // Return items
-    state.items.to_vec().into()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, _query: RStr<'_>) -> RVec<PluginItem> {
-    // Static provider - query is handled by the core using cached items
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<EmojiState>
-        unsafe {
-            handle.drop_as::<EmojiState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_emoji_state_new() {
-        let state = EmojiState::new();
-        assert!(state.items.is_empty());
-    }
-
-    #[test]
-    fn test_emoji_count() {
-        let mut state = EmojiState::new();
-        state.load_emojis();
-        assert!(state.items.len() > 100, "Should have more than 100 emojis");
-    }
-
-    #[test]
-    fn test_emoji_has_grinning_face() {
-        let mut state = EmojiState::new();
-        state.load_emojis();
-
-        let grinning = state
-            .items
-            .iter()
-            .find(|i| i.name.as_str() == "grinning face");
-        assert!(grinning.is_some());
-
-        let item = grinning.unwrap();
-        assert!(item.description.as_ref().unwrap().as_str().contains("😀"));
-    }
-
-    #[test]
-    fn test_emoji_command_format() {
-        let mut state = EmojiState::new();
-        state.load_emojis();
-
-        let item = &state.items[0];
-        assert!(item.command.as_str().contains("wl-copy"));
-        assert!(item.command.as_str().contains("printf"));
-    }
-
-    #[test]
-    fn test_emojis_have_keywords() {
-        let mut state = EmojiState::new();
-        state.load_emojis();
-
-        // Check that items have keywords for searching
-        let heart = state
-            .items
-            .iter()
-            .find(|i| i.name.as_str() == "red heart");
-        assert!(heart.is_some());
-    }
-}

crates/owlry-plugin-filesearch/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "owlry-plugin-filesearch"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "File search plugin for owlry - find files with fd or locate"
-keywords = ["owlry", "plugin", "files", "search"]
-categories = ["filesystem"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"
-
-# For finding home directory
-dirs = "5.0"

crates/owlry-plugin-filesearch/src/lib.rs

@@ -1,322 +0,0 @@
-//! File Search Plugin for Owlry
-//!
-//! A dynamic provider that searches for files using `fd` or `locate`.
-//!
-//! Examples:
-//! - `/ config.toml` → Search for files matching "config.toml"
-//! - `file bashrc` → Search for files matching "bashrc"
-//! - `find readme` → Search for files matching "readme"
-//!
-//! Dependencies:
-//! - fd (preferred) or locate
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-use std::path::Path;
-use std::process::Command;
-
-// Plugin metadata
-const PLUGIN_ID: &str = "filesearch";
-const PLUGIN_NAME: &str = "File Search";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Find files with fd or locate";
-
-// Provider metadata
-const PROVIDER_ID: &str = "filesearch";
-const PROVIDER_NAME: &str = "Files";
-const PROVIDER_PREFIX: &str = "/";
-const PROVIDER_ICON: &str = "folder";
-const PROVIDER_TYPE_ID: &str = "filesearch";
-
-// Maximum results to return
-const MAX_RESULTS: usize = 20;
-
-#[derive(Debug, Clone, Copy)]
-enum SearchTool {
-    Fd,
-    Locate,
-    None,
-}
-
-/// File search provider state
-struct FileSearchState {
-    search_tool: SearchTool,
-    home: String,
-}
-
-impl FileSearchState {
-    fn new() -> Self {
-        let search_tool = Self::detect_search_tool();
-        let home = dirs::home_dir()
-            .map(|p| p.to_string_lossy().to_string())
-            .unwrap_or_else(|| "/".to_string());
-
-        Self { search_tool, home }
-    }
-
-    fn detect_search_tool() -> SearchTool {
-        // Prefer fd (faster, respects .gitignore)
-        if Self::command_exists("fd") {
-            return SearchTool::Fd;
-        }
-        // Fall back to locate (requires updatedb)
-        if Self::command_exists("locate") {
-            return SearchTool::Locate;
-        }
-        SearchTool::None
-    }
-
-    fn command_exists(cmd: &str) -> bool {
-        Command::new("which")
-            .arg(cmd)
-            .output()
-            .map(|o| o.status.success())
-            .unwrap_or(false)
-    }
-
-    /// Extract the search term from the query
-    fn extract_search_term(query: &str) -> Option<&str> {
-        let trimmed = query.trim();
-
-        if let Some(rest) = trimmed.strip_prefix("/ ") {
-            Some(rest.trim())
-        } else if let Some(rest) = trimmed.strip_prefix("/") {
-            Some(rest.trim())
-        } else {
-            // Handle "file " and "find " prefixes (case-insensitive), or raw query in filter mode
-            let lower = trimmed.to_lowercase();
-            if lower.starts_with("file ") || lower.starts_with("find ") {
-                Some(trimmed[5..].trim())
-            } else {
-                Some(trimmed)
-            }
-        }
-    }
-
-    /// Evaluate a query and return file results
-    fn evaluate(&self, query: &str) -> Vec<PluginItem> {
-        let search_term = match Self::extract_search_term(query) {
-            Some(t) if !t.is_empty() => t,
-            _ => return Vec::new(),
-        };
-
-        self.search_files(search_term)
-    }
-
-    fn search_files(&self, pattern: &str) -> Vec<PluginItem> {
-        match self.search_tool {
-            SearchTool::Fd => self.search_with_fd(pattern),
-            SearchTool::Locate => self.search_with_locate(pattern),
-            SearchTool::None => Vec::new(),
-        }
-    }
-
-    fn search_with_fd(&self, pattern: &str) -> Vec<PluginItem> {
-        let output = match Command::new("fd")
-            .args([
-                "--max-results",
-                &MAX_RESULTS.to_string(),
-                "--type",
-                "f", // Files only
-                "--type",
-                "d", // And directories
-                pattern,
-            ])
-            .current_dir(&self.home)
-            .output()
-        {
-            Ok(o) => o,
-            Err(_) => return Vec::new(),
-        };
-
-        self.parse_file_results(&String::from_utf8_lossy(&output.stdout))
-    }
-
-    fn search_with_locate(&self, pattern: &str) -> Vec<PluginItem> {
-        let output = match Command::new("locate")
-            .args([
-                "--limit",
-                &MAX_RESULTS.to_string(),
-                "--ignore-case",
-                pattern,
-            ])
-            .output()
-        {
-            Ok(o) => o,
-            Err(_) => return Vec::new(),
-        };
-
-        self.parse_file_results(&String::from_utf8_lossy(&output.stdout))
-    }
-
-    fn parse_file_results(&self, output: &str) -> Vec<PluginItem> {
-        output
-            .lines()
-            .filter(|line| !line.is_empty())
-            .map(|path| {
-                let path = path.trim();
-                let full_path = if path.starts_with('/') {
-                    path.to_string()
-                } else {
-                    format!("{}/{}", self.home, path)
-                };
-
-                // Get filename for display
-                let filename = Path::new(&full_path)
-                    .file_name()
-                    .map(|n| n.to_string_lossy().to_string())
-                    .unwrap_or_else(|| full_path.clone());
-
-                // Determine icon based on whether it's a directory
-                let is_dir = Path::new(&full_path).is_dir();
-                let icon = if is_dir { "folder" } else { "text-x-generic" };
-
-                // Command to open with xdg-open
-                let command = format!("xdg-open '{}'", full_path.replace('\'', "'\\''"));
-
-                PluginItem::new(format!("file:{}", full_path), filename, command)
-                    .with_description(full_path.clone())
-                    .with_icon(icon)
-                    .with_keywords(vec!["file".to_string()])
-            })
-            .collect()
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Dynamic,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 8000, // Dynamic: file search
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(FileSearchState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(_handle: ProviderHandle) -> RVec<PluginItem> {
-    // Dynamic provider - refresh does nothing
-    RVec::new()
-}
-
-extern "C" fn provider_query(handle: ProviderHandle, query: RStr<'_>) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<FileSearchState>
-    let state = unsafe { &*(handle.ptr as *const FileSearchState) };
-
-    let query_str = query.as_str();
-
-    state.evaluate(query_str).into()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<FileSearchState>
-        unsafe {
-            handle.drop_as::<FileSearchState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_extract_search_term() {
-        assert_eq!(
-            FileSearchState::extract_search_term("/ config.toml"),
-            Some("config.toml")
-        );
-        assert_eq!(
-            FileSearchState::extract_search_term("/config"),
-            Some("config")
-        );
-        assert_eq!(
-            FileSearchState::extract_search_term("file bashrc"),
-            Some("bashrc")
-        );
-        assert_eq!(
-            FileSearchState::extract_search_term("find readme"),
-            Some("readme")
-        );
-    }
-
-    #[test]
-    fn test_extract_search_term_empty() {
-        assert_eq!(FileSearchState::extract_search_term("/"), Some(""));
-        assert_eq!(FileSearchState::extract_search_term("/ "), Some(""));
-    }
-
-    #[test]
-    fn test_command_exists() {
-        // 'which' should exist on any Unix system
-        assert!(FileSearchState::command_exists("which"));
-        // This should not exist
-        assert!(!FileSearchState::command_exists("nonexistent-command-12345"));
-    }
-
-    #[test]
-    fn test_detect_search_tool() {
-        // Just ensure it doesn't panic
-        let _ = FileSearchState::detect_search_tool();
-    }
-
-    #[test]
-    fn test_state_new() {
-        let state = FileSearchState::new();
-        assert!(!state.home.is_empty());
-    }
-
-    #[test]
-    fn test_evaluate_empty() {
-        let state = FileSearchState::new();
-        let results = state.evaluate("/");
-        assert!(results.is_empty());
-
-        let results = state.evaluate("/ ");
-        assert!(results.is_empty());
-    }
-}

crates/owlry-plugin-media/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "owlry-plugin-media"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "MPRIS media player widget plugin for owlry - shows and controls currently playing media. Requires playerctl."
-keywords = ["owlry", "plugin", "media", "mpris", "widget", "playerctl"]
-categories = ["gui"]
-
-# System dependencies (for packagers):
-# - playerctl: for media control commands
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"

crates/owlry-plugin-media/src/lib.rs

@@ -1,468 +0,0 @@
-//! MPRIS Media Player Widget Plugin for Owlry
-//!
-//! Shows currently playing track as a single row with play/pause action.
-//! Uses D-Bus via dbus-send to communicate with MPRIS-compatible players.
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-use std::process::Command;
-
-// Plugin metadata
-const PLUGIN_ID: &str = "media";
-const PLUGIN_NAME: &str = "Media Player";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "MPRIS media player widget - shows and controls currently playing media";
-
-// Provider metadata
-const PROVIDER_ID: &str = "media";
-const PROVIDER_NAME: &str = "Media";
-const PROVIDER_ICON: &str = "applications-multimedia";
-const PROVIDER_TYPE_ID: &str = "media";
-
-#[derive(Debug, Default, Clone)]
-struct MediaState {
-    player_name: String,
-    title: String,
-    artist: String,
-    is_playing: bool,
-}
-
-/// Media provider state
-struct MediaProviderState {
-    items: Vec<PluginItem>,
-    /// Current player name for submenu actions
-    current_player: Option<String>,
-    /// Current playback state
-    is_playing: bool,
-}
-
-impl MediaProviderState {
-    fn new() -> Self {
-        // Don't query D-Bus during init - defer to first refresh() call
-        // This prevents blocking the main thread during startup
-        Self {
-            items: Vec::new(),
-            current_player: None,
-            is_playing: false,
-        }
-    }
-
-    fn refresh(&mut self) {
-        self.items.clear();
-
-        let players = Self::find_players();
-        if players.is_empty() {
-            return;
-        }
-
-        // Find first active player
-        for player in &players {
-            if let Some(state) = Self::get_player_state(player) {
-                self.generate_items(&state);
-                return;
-            }
-        }
-    }
-
-    /// Find active MPRIS players via dbus-send
-    fn find_players() -> Vec<String> {
-        let output = Command::new("dbus-send")
-            .args([
-                "--session",
-                "--dest=org.freedesktop.DBus",
-                "--type=method_call",
-                "--print-reply",
-                "/org/freedesktop/DBus",
-                "org.freedesktop.DBus.ListNames",
-            ])
-            .output();
-
-        match output {
-            Ok(out) => {
-                let stdout = String::from_utf8_lossy(&out.stdout);
-                stdout
-                    .lines()
-                    .filter_map(|line| {
-                        let trimmed = line.trim();
-                        if trimmed.starts_with("string \"org.mpris.MediaPlayer2.") {
-                            let start = "string \"org.mpris.MediaPlayer2.".len();
-                            let end = trimmed.len() - 1;
-                            Some(trimmed[start..end].to_string())
-                        } else {
-                            None
-                        }
-                    })
-                    .collect()
-            }
-            Err(_) => Vec::new(),
-        }
-    }
-
-    /// Get metadata from an MPRIS player
-    fn get_player_state(player: &str) -> Option<MediaState> {
-        let dest = format!("org.mpris.MediaPlayer2.{}", player);
-
-        // Get playback status
-        let status_output = Command::new("dbus-send")
-            .args([
-                "--session",
-                &format!("--dest={}", dest),
-                "--type=method_call",
-                "--print-reply",
-                "/org/mpris/MediaPlayer2",
-                "org.freedesktop.DBus.Properties.Get",
-                "string:org.mpris.MediaPlayer2.Player",
-                "string:PlaybackStatus",
-            ])
-            .output()
-            .ok()?;
-
-        let status_str = String::from_utf8_lossy(&status_output.stdout);
-        let is_playing = status_str.contains("\"Playing\"");
-        let is_paused = status_str.contains("\"Paused\"");
-
-        // Only show if playing or paused (not stopped)
-        if !is_playing && !is_paused {
-            return None;
-        }
-
-        // Get metadata
-        let metadata_output = Command::new("dbus-send")
-            .args([
-                "--session",
-                &format!("--dest={}", dest),
-                "--type=method_call",
-                "--print-reply",
-                "/org/mpris/MediaPlayer2",
-                "org.freedesktop.DBus.Properties.Get",
-                "string:org.mpris.MediaPlayer2.Player",
-                "string:Metadata",
-            ])
-            .output()
-            .ok()?;
-
-        let metadata_str = String::from_utf8_lossy(&metadata_output.stdout);
-
-        let title = Self::extract_string(&metadata_str, "xesam:title")
-            .unwrap_or_else(|| "Unknown".to_string());
-        let artist = Self::extract_array(&metadata_str, "xesam:artist")
-            .unwrap_or_else(|| "Unknown".to_string());
-
-        Some(MediaState {
-            player_name: player.to_string(),
-            title,
-            artist,
-            is_playing,
-        })
-    }
-
-    /// Extract string value from D-Bus output
-    fn extract_string(output: &str, key: &str) -> Option<String> {
-        let key_pattern = format!("\"{}\"", key);
-        let mut found = false;
-
-        for line in output.lines() {
-            let trimmed = line.trim();
-            if trimmed.contains(&key_pattern) {
-                found = true;
-                continue;
-            }
-            if found {
-                if let Some(pos) = trimmed.find("string \"") {
-                    let start = pos + "string \"".len();
-                    if let Some(end) = trimmed[start..].find('"') {
-                        let value = &trimmed[start..start + end];
-                        if !value.is_empty() {
-                            return Some(value.to_string());
-                        }
-                    }
-                }
-                if !trimmed.starts_with("variant") {
-                    found = false;
-                }
-            }
-        }
-        None
-    }
-
-    /// Extract array value from D-Bus output
-    fn extract_array(output: &str, key: &str) -> Option<String> {
-        let key_pattern = format!("\"{}\"", key);
-        let mut found = false;
-        let mut in_array = false;
-        let mut values = Vec::new();
-
-        for line in output.lines() {
-            let trimmed = line.trim();
-            if trimmed.contains(&key_pattern) {
-                found = true;
-                continue;
-            }
-            if found && trimmed.contains("array [") {
-                in_array = true;
-                continue;
-            }
-            if in_array {
-                if let Some(pos) = trimmed.find("string \"") {
-                    let start = pos + "string \"".len();
-                    if let Some(end) = trimmed[start..].find('"') {
-                        values.push(trimmed[start..start + end].to_string());
-                    }
-                }
-                if trimmed.contains(']') {
-                    break;
-                }
-            }
-        }
-
-        if values.is_empty() {
-            None
-        } else {
-            Some(values.join(", "))
-        }
-    }
-
-    /// Generate single LaunchItem for media state (opens submenu)
-    fn generate_items(&mut self, state: &MediaState) {
-        self.items.clear();
-
-        // Store state for submenu
-        self.current_player = Some(state.player_name.clone());
-        self.is_playing = state.is_playing;
-
-        // Single row: "Title — Artist"
-        let name = format!("{} — {}", state.title, state.artist);
-
-        // Extract player display name (e.g., "firefox.instance_1_94" -> "Firefox")
-        let player_display = Self::format_player_name(&state.player_name);
-
-        // Opens submenu with media controls
-        self.items.push(
-            PluginItem::new("media-now-playing", name, "SUBMENU:media:controls")
-                .with_description(format!("{} · Select for controls", player_display))
-                .with_icon("/org/owlry/launcher/icons/media/music-note.svg")
-                .with_keywords(vec!["media".to_string(), "widget".to_string()]),
-        );
-    }
-
-    /// Format player name for display
-    fn format_player_name(player_name: &str) -> String {
-        let player_display = player_name.split('.').next().unwrap_or(player_name);
-        if player_display.is_empty() {
-            "Player".to_string()
-        } else {
-            let mut chars = player_display.chars();
-            match chars.next() {
-                None => "Player".to_string(),
-                Some(first) => first.to_uppercase().chain(chars).collect(),
-            }
-        }
-    }
-
-    /// Generate submenu items for media controls
-    fn generate_submenu_items(&self) -> Vec<PluginItem> {
-        let player = match &self.current_player {
-            Some(p) => p,
-            None => return Vec::new(),
-        };
-
-        let mut items = Vec::new();
-
-        // Use playerctl for simpler, more reliable media control
-        // playerctl -p <player> <command>
-
-        // Play/Pause
-        if self.is_playing {
-            items.push(
-                PluginItem::new(
-                    "media-pause",
-                    "Pause",
-                    format!("playerctl -p {} pause", player),
-                )
-                .with_description("Pause playback")
-                .with_icon("media-playback-pause"),
-            );
-        } else {
-            items.push(
-                PluginItem::new(
-                    "media-play",
-                    "Play",
-                    format!("playerctl -p {} play", player),
-                )
-                .with_description("Resume playback")
-                .with_icon("media-playback-start"),
-            );
-        }
-
-        // Next track
-        items.push(
-            PluginItem::new(
-                "media-next",
-                "Next",
-                format!("playerctl -p {} next", player),
-            )
-            .with_description("Skip to next track")
-            .with_icon("media-skip-forward"),
-        );
-
-        // Previous track
-        items.push(
-            PluginItem::new(
-                "media-previous",
-                "Previous",
-                format!("playerctl -p {} previous", player),
-            )
-            .with_description("Go to previous track")
-            .with_icon("media-skip-backward"),
-        );
-
-        // Stop
-        items.push(
-            PluginItem::new(
-                "media-stop",
-                "Stop",
-                format!("playerctl -p {} stop", player),
-            )
-            .with_description("Stop playback")
-            .with_icon("media-playback-stop"),
-        );
-
-        items
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RNone,
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Widget,
-        priority: 11000, // Widget: media player
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(MediaProviderState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<MediaProviderState>
-    let state = unsafe { &mut *(handle.ptr as *mut MediaProviderState) };
-
-    state.refresh();
-    state.items.clone().into()
-}
-
-extern "C" fn provider_query(handle: ProviderHandle, query: RStr<'_>) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    let query_str = query.as_str();
-    let state = unsafe { &*(handle.ptr as *const MediaProviderState) };
-
-    // Handle submenu request
-    if query_str == "?SUBMENU:controls" {
-        return state.generate_submenu_items().into();
-    }
-
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<MediaProviderState>
-        unsafe {
-            handle.drop_as::<MediaProviderState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_extract_string() {
-        let output = r#"
-            string "xesam:title"
-            variant       string "My Song Title"
-        "#;
-        assert_eq!(
-            MediaProviderState::extract_string(output, "xesam:title"),
-            Some("My Song Title".to_string())
-        );
-    }
-
-    #[test]
-    fn test_extract_array() {
-        let output = r#"
-            string "xesam:artist"
-            variant       array [
-                string "Artist One"
-                string "Artist Two"
-            ]
-        "#;
-        assert_eq!(
-            MediaProviderState::extract_array(output, "xesam:artist"),
-            Some("Artist One, Artist Two".to_string())
-        );
-    }
-
-    #[test]
-    fn test_extract_string_not_found() {
-        let output = "some other output";
-        assert_eq!(
-            MediaProviderState::extract_string(output, "xesam:title"),
-            None
-        );
-    }
-
-    #[test]
-    fn test_find_players_empty() {
-        // This will return empty on systems without D-Bus
-        let players = MediaProviderState::find_players();
-        // Just verify it doesn't panic
-        let _ = players;
-    }
-}

crates/owlry-plugin-pomodoro/Cargo.toml

@@ -1,30 +0,0 @@
-[package]
-name = "owlry-plugin-pomodoro"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Pomodoro timer widget plugin for owlry - work/break cycles with persistent state"
-keywords = ["owlry", "plugin", "pomodoro", "timer", "widget"]
-categories = ["gui"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"
-
-# JSON serialization for persistent state
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-
-# TOML config parsing
-toml = "0.8"
-
-# For finding data directory
-dirs = "5.0"

crates/owlry-plugin-pomodoro/src/lib.rs

@@ -1,478 +0,0 @@
-//! Pomodoro Timer Widget Plugin for Owlry
-//!
-//! Shows timer with work/break cycles. Select to open controls submenu.
-//! State persists across sessions via JSON file.
-//!
-//! ## Configuration
-//!
-//! Configure via `~/.config/owlry/config.toml`:
-//!
-//! ```toml
-//! [plugins.pomodoro]
-//! work_mins = 25      # Work session duration (default: 25)
-//! break_mins = 5      # Break duration (default: 5)
-//! ```
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    notify_with_urgency, owlry_plugin, NotifyUrgency, PluginInfo, PluginItem, ProviderHandle,
-    ProviderInfo, ProviderKind, ProviderPosition, API_VERSION,
-};
-use serde::{Deserialize, Serialize};
-use std::fs;
-use std::path::PathBuf;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-// Plugin metadata
-const PLUGIN_ID: &str = "pomodoro";
-const PLUGIN_NAME: &str = "Pomodoro Timer";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Pomodoro timer widget with work/break cycles";
-
-// Provider metadata
-const PROVIDER_ID: &str = "pomodoro";
-const PROVIDER_NAME: &str = "Pomodoro";
-const PROVIDER_ICON: &str = "alarm";
-const PROVIDER_TYPE_ID: &str = "pomodoro";
-
-// Default timing (in minutes)
-const DEFAULT_WORK_MINS: u32 = 25;
-const DEFAULT_BREAK_MINS: u32 = 5;
-
-/// Pomodoro configuration
-#[derive(Debug, Clone)]
-struct PomodoroConfig {
-    work_mins: u32,
-    break_mins: u32,
-}
-
-impl PomodoroConfig {
-    /// Load config from ~/.config/owlry/config.toml
-    ///
-    /// Reads from [plugins.pomodoro] section, with fallback to [providers] for compatibility.
-    fn load() -> Self {
-        let config_path = dirs::config_dir()
-            .map(|d| d.join("owlry").join("config.toml"));
-
-        let config_content = config_path
-            .and_then(|p| fs::read_to_string(p).ok());
-
-        if let Some(content) = config_content
-            && let Ok(toml) = content.parse::<toml::Table>()
-        {
-            // Try [plugins.pomodoro] first (new format)
-            if let Some(plugins) = toml.get("plugins").and_then(|v| v.as_table())
-                && let Some(pomodoro) = plugins.get("pomodoro").and_then(|v| v.as_table())
-            {
-                return Self::from_toml_table(pomodoro);
-            }
-
-            // Fallback to [providers] section (old format)
-            if let Some(providers) = toml.get("providers").and_then(|v| v.as_table()) {
-                let work_mins = providers
-                    .get("pomodoro_work_mins")
-                    .and_then(|v| v.as_integer())
-                    .map(|v| v as u32)
-                    .unwrap_or(DEFAULT_WORK_MINS);
-
-                let break_mins = providers
-                    .get("pomodoro_break_mins")
-                    .and_then(|v| v.as_integer())
-                    .map(|v| v as u32)
-                    .unwrap_or(DEFAULT_BREAK_MINS);
-
-                return Self { work_mins, break_mins };
-            }
-        }
-
-        // Default config
-        Self {
-            work_mins: DEFAULT_WORK_MINS,
-            break_mins: DEFAULT_BREAK_MINS,
-        }
-    }
-
-    /// Parse config from a TOML table
-    fn from_toml_table(table: &toml::Table) -> Self {
-        let work_mins = table
-            .get("work_mins")
-            .and_then(|v| v.as_integer())
-            .map(|v| v as u32)
-            .unwrap_or(DEFAULT_WORK_MINS);
-
-        let break_mins = table
-            .get("break_mins")
-            .and_then(|v| v.as_integer())
-            .map(|v| v as u32)
-            .unwrap_or(DEFAULT_BREAK_MINS);
-
-        Self { work_mins, break_mins }
-    }
-}
-
-/// Timer phase
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Default)]
-enum PomodoroPhase {
-    #[default]
-    Idle,
-    Working,
-    WorkPaused,
-    Break,
-    BreakPaused,
-}
-
-/// Persistent state (saved to disk)
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-struct PomodoroState {
-    phase: PomodoroPhase,
-    remaining_secs: u32,
-    sessions: u32,
-    last_update: u64,
-}
-
-/// Pomodoro provider state
-struct PomodoroProviderState {
-    items: Vec<PluginItem>,
-    state: PomodoroState,
-    work_mins: u32,
-    break_mins: u32,
-}
-
-impl PomodoroProviderState {
-    fn new() -> Self {
-        let config = PomodoroConfig::load();
-
-        let state = Self::load_state().unwrap_or_else(|| PomodoroState {
-            phase: PomodoroPhase::Idle,
-            remaining_secs: config.work_mins * 60,
-            sessions: 0,
-            last_update: Self::now_secs(),
-        });
-
-        let mut provider = Self {
-            items: Vec::new(),
-            state,
-            work_mins: config.work_mins,
-            break_mins: config.break_mins,
-        };
-
-        provider.update_elapsed_time();
-        provider.generate_items();
-        provider
-    }
-
-    fn now_secs() -> u64 {
-        SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_secs()
-    }
-
-    fn data_dir() -> Option<PathBuf> {
-        dirs::data_dir().map(|d| d.join("owlry"))
-    }
-
-    fn load_state() -> Option<PomodoroState> {
-        let path = Self::data_dir()?.join("pomodoro.json");
-        let content = fs::read_to_string(&path).ok()?;
-        serde_json::from_str(&content).ok()
-    }
-
-    fn save_state(&self) {
-        if let Some(data_dir) = Self::data_dir() {
-            let path = data_dir.join("pomodoro.json");
-            if fs::create_dir_all(&data_dir).is_err() {
-                return;
-            }
-            let mut state = self.state.clone();
-            state.last_update = Self::now_secs();
-            if let Ok(json) = serde_json::to_string_pretty(&state) {
-                let _ = fs::write(&path, json);
-            }
-        }
-    }
-
-    fn update_elapsed_time(&mut self) {
-        let now = Self::now_secs();
-        let elapsed = now.saturating_sub(self.state.last_update);
-
-        match self.state.phase {
-            PomodoroPhase::Working | PomodoroPhase::Break => {
-                if elapsed >= self.state.remaining_secs as u64 {
-                    self.complete_phase();
-                } else {
-                    self.state.remaining_secs -= elapsed as u32;
-                }
-            }
-            _ => {}
-        }
-        self.state.last_update = now;
-    }
-
-    fn complete_phase(&mut self) {
-        match self.state.phase {
-            PomodoroPhase::Working => {
-                self.state.sessions += 1;
-                self.state.phase = PomodoroPhase::Break;
-                self.state.remaining_secs = self.break_mins * 60;
-                notify_with_urgency(
-                    "Pomodoro Complete!",
-                    &format!(
-                        "Great work! Session {} complete. Time for a {}-minute break.",
-                        self.state.sessions, self.break_mins
-                    ),
-                    "alarm",
-                    NotifyUrgency::Normal,
-                );
-            }
-            PomodoroPhase::Break => {
-                self.state.phase = PomodoroPhase::Idle;
-                self.state.remaining_secs = self.work_mins * 60;
-                notify_with_urgency(
-                    "Break Complete",
-                    "Break time's over! Ready for another work session?",
-                    "alarm",
-                    NotifyUrgency::Normal,
-                );
-            }
-            _ => {}
-        }
-        self.save_state();
-    }
-
-    fn refresh(&mut self) {
-        self.update_elapsed_time();
-        self.generate_items();
-    }
-
-    fn handle_action(&mut self, action: &str) {
-        match action {
-            "start" => {
-                self.state.phase = PomodoroPhase::Working;
-                self.state.remaining_secs = self.work_mins * 60;
-                self.state.last_update = Self::now_secs();
-            }
-            "pause" => match self.state.phase {
-                PomodoroPhase::Working => self.state.phase = PomodoroPhase::WorkPaused,
-                PomodoroPhase::Break => self.state.phase = PomodoroPhase::BreakPaused,
-                _ => {}
-            },
-            "resume" => {
-                self.state.last_update = Self::now_secs();
-                match self.state.phase {
-                    PomodoroPhase::WorkPaused => self.state.phase = PomodoroPhase::Working,
-                    PomodoroPhase::BreakPaused => self.state.phase = PomodoroPhase::Break,
-                    _ => {}
-                }
-            }
-            "skip" => self.complete_phase(),
-            "reset" => {
-                self.state.phase = PomodoroPhase::Idle;
-                self.state.remaining_secs = self.work_mins * 60;
-                self.state.sessions = 0;
-            }
-            _ => {}
-        }
-        self.save_state();
-        self.generate_items();
-    }
-
-    fn format_time(secs: u32) -> String {
-        let mins = secs / 60;
-        let secs = secs % 60;
-        format!("{:02}:{:02}", mins, secs)
-    }
-
-    /// Generate single main item with submenu for controls
-    fn generate_items(&mut self) {
-        self.items.clear();
-
-        let (phase_name, _is_running) = match self.state.phase {
-            PomodoroPhase::Idle => ("Ready", false),
-            PomodoroPhase::Working => ("Work", true),
-            PomodoroPhase::WorkPaused => ("Paused", false),
-            PomodoroPhase::Break => ("Break", true),
-            PomodoroPhase::BreakPaused => ("Paused", false),
-        };
-
-        let time_str = Self::format_time(self.state.remaining_secs);
-        let name = format!("{}: {}", phase_name, time_str);
-
-        let description = if self.state.sessions > 0 {
-            format!(
-                "Sessions: {} | {}min work / {}min break",
-                self.state.sessions, self.work_mins, self.break_mins
-            )
-        } else {
-            format!("{}min work / {}min break", self.work_mins, self.break_mins)
-        };
-
-        // Single item that opens submenu with controls
-        self.items.push(
-            PluginItem::new("pomo-timer", name, "SUBMENU:pomodoro:controls")
-                .with_description(description)
-                .with_icon("/org/owlry/launcher/icons/pomodoro/tomato.svg")
-                .with_keywords(vec![
-                    "pomodoro".to_string(),
-                    "widget".to_string(),
-                    "timer".to_string(),
-                ]),
-        );
-    }
-
-    /// Generate submenu items for controls
-    fn generate_submenu_items(&self) -> Vec<PluginItem> {
-        let mut items = Vec::new();
-        let is_running = matches!(
-            self.state.phase,
-            PomodoroPhase::Working | PomodoroPhase::Break
-        );
-
-        // Primary control: Start/Pause/Resume
-        if is_running {
-            items.push(
-                PluginItem::new("pomo-pause", "Pause", "POMODORO:pause")
-                    .with_description("Pause the timer")
-                    .with_icon("media-playback-pause"),
-            );
-        } else {
-            match self.state.phase {
-                PomodoroPhase::Idle => {
-                    items.push(
-                        PluginItem::new("pomo-start", "Start Work", "POMODORO:start")
-                            .with_description("Start a new work session")
-                            .with_icon("media-playback-start"),
-                    );
-                }
-                _ => {
-                    items.push(
-                        PluginItem::new("pomo-resume", "Resume", "POMODORO:resume")
-                            .with_description("Resume the timer")
-                            .with_icon("media-playback-start"),
-                    );
-                }
-            }
-        }
-
-        // Skip (only when not idle)
-        if self.state.phase != PomodoroPhase::Idle {
-            items.push(
-                PluginItem::new("pomo-skip", "Skip", "POMODORO:skip")
-                    .with_description("Skip to next phase")
-                    .with_icon("media-skip-forward"),
-            );
-        }
-
-        // Reset
-        items.push(
-            PluginItem::new("pomo-reset", "Reset", "POMODORO:reset")
-                .with_description("Reset timer and sessions")
-                .with_icon("view-refresh"),
-        );
-
-        items
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RNone,
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Widget,
-        priority: 11500, // Widget: pomodoro timer
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(PomodoroProviderState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    let state = unsafe { &mut *(handle.ptr as *mut PomodoroProviderState) };
-    state.refresh();
-    state.items.clone().into()
-}
-
-extern "C" fn provider_query(handle: ProviderHandle, query: RStr<'_>) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    let query_str = query.as_str();
-    let state = unsafe { &mut *(handle.ptr as *mut PomodoroProviderState) };
-
-    // Handle submenu request
-    if query_str == "?SUBMENU:controls" {
-        return state.generate_submenu_items().into();
-    }
-
-    // Handle action commands
-    if let Some(action) = query_str.strip_prefix("!POMODORO:") {
-        state.handle_action(action);
-    }
-
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        let state = unsafe { &*(handle.ptr as *const PomodoroProviderState) };
-        state.save_state();
-        unsafe {
-            handle.drop_as::<PomodoroProviderState>();
-        }
-    }
-}
-
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_format_time() {
-        assert_eq!(PomodoroProviderState::format_time(0), "00:00");
-        assert_eq!(PomodoroProviderState::format_time(60), "01:00");
-        assert_eq!(PomodoroProviderState::format_time(90), "01:30");
-        assert_eq!(PomodoroProviderState::format_time(1500), "25:00");
-        assert_eq!(PomodoroProviderState::format_time(3599), "59:59");
-    }
-
-    #[test]
-    fn test_default_phase() {
-        let phase: PomodoroPhase = Default::default();
-        assert_eq!(phase, PomodoroPhase::Idle);
-    }
-}

crates/owlry-plugin-scripts/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "owlry-plugin-scripts"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Scripts plugin for owlry - run user scripts from ~/.local/share/owlry/scripts/"
-keywords = ["owlry", "plugin", "scripts"]
-categories = ["os"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"
-
-# For finding ~/.local/share/owlry/scripts
-dirs = "5.0"

crates/owlry-plugin-scripts/src/lib.rs

@@ -1,290 +0,0 @@
-//! Scripts Plugin for Owlry
-//!
-//! A static provider that scans `~/.local/share/owlry/scripts/` for executable
-//! scripts and provides them as launch items.
-//!
-//! Scripts can include a description by adding a comment after the shebang:
-//! ```bash
-//! #!/bin/bash
-//! # This is my script description
-//! echo "Hello"
-//! ```
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-use std::fs;
-use std::os::unix::fs::PermissionsExt;
-use std::path::PathBuf;
-
-// Plugin metadata
-const PLUGIN_ID: &str = "scripts";
-const PLUGIN_NAME: &str = "Scripts";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Run user scripts from ~/.local/share/owlry/scripts/";
-
-// Provider metadata
-const PROVIDER_ID: &str = "scripts";
-const PROVIDER_NAME: &str = "Scripts";
-const PROVIDER_PREFIX: &str = ":script";
-const PROVIDER_ICON: &str = "utilities-terminal";
-const PROVIDER_TYPE_ID: &str = "scripts";
-
-/// Scripts provider state - holds cached items
-struct ScriptsState {
-    items: Vec<PluginItem>,
-}
-
-impl ScriptsState {
-    fn new() -> Self {
-        Self { items: Vec::new() }
-    }
-
-    fn scripts_dir() -> Option<PathBuf> {
-        dirs::data_dir().map(|d| d.join("owlry").join("scripts"))
-    }
-
-    fn load_scripts(&mut self) {
-        self.items.clear();
-
-        let scripts_dir = match Self::scripts_dir() {
-            Some(p) => p,
-            None => return,
-        };
-
-        if !scripts_dir.exists() {
-            // Create the directory for the user
-            let _ = fs::create_dir_all(&scripts_dir);
-            return;
-        }
-
-        let entries = match fs::read_dir(&scripts_dir) {
-            Ok(e) => e,
-            Err(_) => return,
-        };
-
-        for entry in entries.flatten() {
-            let path = entry.path();
-
-            // Skip directories
-            if path.is_dir() {
-                continue;
-            }
-
-            // Check if executable
-            let metadata = match path.metadata() {
-                Ok(m) => m,
-                Err(_) => continue,
-            };
-
-            let is_executable = metadata.permissions().mode() & 0o111 != 0;
-            if !is_executable {
-                continue;
-            }
-
-            // Get script name without extension
-            let filename = path
-                .file_name()
-                .map(|n| n.to_string_lossy().to_string())
-                .unwrap_or_default();
-
-            let name = path
-                .file_stem()
-                .map(|n| n.to_string_lossy().to_string())
-                .unwrap_or(filename.clone());
-
-            // Try to read description from first line comment
-            let description = Self::read_script_description(&path);
-
-            // Determine icon based on extension or shebang
-            let icon = Self::determine_icon(&path);
-
-            let mut item = PluginItem::new(
-                format!("script:{}", filename),
-                format!("Script: {}", name),
-                path.to_string_lossy().to_string(),
-            )
-            .with_icon(icon)
-            .with_keywords(vec!["script".to_string()]);
-
-            if let Some(desc) = description {
-                item = item.with_description(desc);
-            }
-
-            self.items.push(item);
-        }
-    }
-
-    fn read_script_description(path: &PathBuf) -> Option<String> {
-        let content = fs::read_to_string(path).ok()?;
-        let mut lines = content.lines();
-
-        // Skip shebang if present
-        let first_line = lines.next()?;
-        let check_line = if first_line.starts_with("#!") {
-            lines.next()?
-        } else {
-            first_line
-        };
-
-        // Look for a comment description
-        if let Some(desc) = check_line.strip_prefix("# ") {
-            Some(desc.trim().to_string())
-        } else { check_line.strip_prefix("// ").map(|desc| desc.trim().to_string()) }
-    }
-
-    fn determine_icon(path: &PathBuf) -> String {
-        // Check extension first
-        if let Some(ext) = path.extension() {
-            match ext.to_string_lossy().as_ref() {
-                "sh" | "bash" | "zsh" => return "utilities-terminal".to_string(),
-                "py" | "python" => return "text-x-python".to_string(),
-                "js" | "ts" => return "text-x-javascript".to_string(),
-                "rb" => return "text-x-ruby".to_string(),
-                "pl" => return "text-x-perl".to_string(),
-                _ => {}
-            }
-        }
-
-        // Check shebang
-        if let Ok(content) = fs::read_to_string(path)
-            && let Some(first_line) = content.lines().next() {
-                if first_line.contains("bash") || first_line.contains("sh") {
-                    return "utilities-terminal".to_string();
-                } else if first_line.contains("python") {
-                    return "text-x-python".to_string();
-                } else if first_line.contains("node") {
-                    return "text-x-javascript".to_string();
-                } else if first_line.contains("ruby") {
-                    return "text-x-ruby".to_string();
-                }
-            }
-
-        "application-x-executable".to_string()
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 0, // Static: use frecency ordering
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(ScriptsState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<ScriptsState>
-    let state = unsafe { &mut *(handle.ptr as *mut ScriptsState) };
-
-    // Load scripts
-    state.load_scripts();
-
-    // Return items
-    state.items.to_vec().into()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, _query: RStr<'_>) -> RVec<PluginItem> {
-    // Static provider - query is handled by the core using cached items
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<ScriptsState>
-        unsafe {
-            handle.drop_as::<ScriptsState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_scripts_state_new() {
-        let state = ScriptsState::new();
-        assert!(state.items.is_empty());
-    }
-
-    #[test]
-    fn test_determine_icon_sh() {
-        let path = PathBuf::from("/test/script.sh");
-        let icon = ScriptsState::determine_icon(&path);
-        assert_eq!(icon, "utilities-terminal");
-    }
-
-    #[test]
-    fn test_determine_icon_python() {
-        let path = PathBuf::from("/test/script.py");
-        let icon = ScriptsState::determine_icon(&path);
-        assert_eq!(icon, "text-x-python");
-    }
-
-    #[test]
-    fn test_determine_icon_js() {
-        let path = PathBuf::from("/test/script.js");
-        let icon = ScriptsState::determine_icon(&path);
-        assert_eq!(icon, "text-x-javascript");
-    }
-
-    #[test]
-    fn test_determine_icon_unknown() {
-        let path = PathBuf::from("/test/script.xyz");
-        let icon = ScriptsState::determine_icon(&path);
-        assert_eq!(icon, "application-x-executable");
-    }
-
-    #[test]
-    fn test_scripts_dir() {
-        // Should return Some path
-        let dir = ScriptsState::scripts_dir();
-        assert!(dir.is_some());
-        assert!(dir.unwrap().ends_with("owlry/scripts"));
-    }
-}

crates/owlry-plugin-ssh/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "owlry-plugin-ssh"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "SSH plugin for owlry - quick connect to SSH hosts from ~/.ssh/config"
-keywords = ["owlry", "plugin", "ssh"]
-categories = ["network-programming"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"
-
-# For finding ~/.ssh/config
-dirs = "5.0"

crates/owlry-plugin-ssh/src/lib.rs

@@ -1,328 +0,0 @@
-//! SSH Plugin for Owlry
-//!
-//! A static provider that parses ~/.ssh/config and provides quick-connect
-//! entries for SSH hosts.
-//!
-//! Examples:
-//! - `SSH: myserver` → Connect to myserver
-//! - `SSH: work-box` → Connect to work-box with configured user/port
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-use std::fs;
-use std::path::PathBuf;
-
-// Plugin metadata
-const PLUGIN_ID: &str = "ssh";
-const PLUGIN_NAME: &str = "SSH";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Quick connect to SSH hosts from ~/.ssh/config";
-
-// Provider metadata
-const PROVIDER_ID: &str = "ssh";
-const PROVIDER_NAME: &str = "SSH";
-const PROVIDER_PREFIX: &str = ":ssh";
-const PROVIDER_ICON: &str = "utilities-terminal";
-const PROVIDER_TYPE_ID: &str = "ssh";
-
-// Default terminal command (TODO: make configurable via plugin config)
-const DEFAULT_TERMINAL: &str = "kitty";
-
-/// SSH provider state - holds cached items
-struct SshState {
-    items: Vec<PluginItem>,
-    terminal_command: String,
-}
-
-impl SshState {
-    fn new() -> Self {
-        // Try to detect terminal from environment, fall back to default
-        let terminal = std::env::var("TERMINAL")
-            .unwrap_or_else(|_| DEFAULT_TERMINAL.to_string());
-
-        Self {
-            items: Vec::new(),
-            terminal_command: terminal,
-        }
-    }
-
-    fn ssh_config_path() -> Option<PathBuf> {
-        dirs::home_dir().map(|h| h.join(".ssh").join("config"))
-    }
-
-    fn parse_ssh_config(&mut self) {
-        self.items.clear();
-
-        let config_path = match Self::ssh_config_path() {
-            Some(p) => p,
-            None => return,
-        };
-
-        if !config_path.exists() {
-            return;
-        }
-
-        let content = match fs::read_to_string(&config_path) {
-            Ok(c) => c,
-            Err(_) => return,
-        };
-
-        let mut current_host: Option<String> = None;
-        let mut current_hostname: Option<String> = None;
-        let mut current_user: Option<String> = None;
-        let mut current_port: Option<String> = None;
-
-        for line in content.lines() {
-            let line = line.trim();
-
-            // Skip comments and empty lines
-            if line.is_empty() || line.starts_with('#') {
-                continue;
-            }
-
-            // Split on whitespace or '='
-            let parts: Vec<&str> = line
-                .splitn(2, |c: char| c.is_whitespace() || c == '=')
-                .map(|s| s.trim())
-                .filter(|s| !s.is_empty())
-                .collect();
-
-            if parts.len() < 2 {
-                continue;
-            }
-
-            let key = parts[0].to_lowercase();
-            let value = parts[1];
-
-            match key.as_str() {
-                "host" => {
-                    // Save previous host if exists
-                    if let Some(host) = current_host.take() {
-                        self.add_host_item(
-                            &host,
-                            current_hostname.take(),
-                            current_user.take(),
-                            current_port.take(),
-                        );
-                    }
-
-                    // Skip wildcards and patterns
-                    if !value.contains('*') && !value.contains('?') && value != "*" {
-                        current_host = Some(value.to_string());
-                    }
-                    current_hostname = None;
-                    current_user = None;
-                    current_port = None;
-                }
-                "hostname" => {
-                    current_hostname = Some(value.to_string());
-                }
-                "user" => {
-                    current_user = Some(value.to_string());
-                }
-                "port" => {
-                    current_port = Some(value.to_string());
-                }
-                _ => {}
-            }
-        }
-
-        // Don't forget the last host
-        if let Some(host) = current_host.take() {
-            self.add_host_item(&host, current_hostname, current_user, current_port);
-        }
-    }
-
-    fn add_host_item(
-        &mut self,
-        host: &str,
-        hostname: Option<String>,
-        user: Option<String>,
-        port: Option<String>,
-    ) {
-        // Build description
-        let mut desc_parts = Vec::new();
-        if let Some(ref h) = hostname {
-            desc_parts.push(h.clone());
-        }
-        if let Some(ref u) = user {
-            desc_parts.push(format!("user: {}", u));
-        }
-        if let Some(ref p) = port {
-            desc_parts.push(format!("port: {}", p));
-        }
-
-        let description = if desc_parts.is_empty() {
-            None
-        } else {
-            Some(desc_parts.join(", "))
-        };
-
-        // Build SSH command - just use the host alias, SSH will resolve the rest
-        let ssh_command = format!("ssh {}", host);
-
-        // Wrap in terminal
-        let command = format!("{} -e {}", self.terminal_command, ssh_command);
-
-        let mut item = PluginItem::new(
-            format!("ssh:{}", host),
-            format!("SSH: {}", host),
-            command,
-        )
-        .with_icon(PROVIDER_ICON)
-        .with_keywords(vec!["ssh".to_string(), "remote".to_string()]);
-
-        if let Some(desc) = description {
-            item = item.with_description(desc);
-        }
-
-        self.items.push(item);
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 0, // Static: use frecency ordering
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(SshState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<SshState>
-    let state = unsafe { &mut *(handle.ptr as *mut SshState) };
-
-    // Parse SSH config
-    state.parse_ssh_config();
-
-    // Return items
-    state.items.to_vec().into()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, _query: RStr<'_>) -> RVec<PluginItem> {
-    // Static provider - query is handled by the core using cached items
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<SshState>
-        unsafe {
-            handle.drop_as::<SshState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_ssh_state_new() {
-        let state = SshState::new();
-        assert!(state.items.is_empty());
-    }
-
-    #[test]
-    fn test_parse_simple_config() {
-        let mut state = SshState::new();
-
-        // We can't easily test the full flow without mocking file paths,
-        // but we can test the add_host_item method
-        state.add_host_item(
-            "myserver",
-            Some("192.168.1.100".to_string()),
-            Some("admin".to_string()),
-            Some("2222".to_string()),
-        );
-
-        assert_eq!(state.items.len(), 1);
-        assert_eq!(state.items[0].name.as_str(), "SSH: myserver");
-        assert!(state.items[0].command.as_str().contains("ssh myserver"));
-    }
-
-    #[test]
-    fn test_add_host_without_details() {
-        let mut state = SshState::new();
-        state.add_host_item("simple-host", None, None, None);
-
-        assert_eq!(state.items.len(), 1);
-        assert_eq!(state.items[0].name.as_str(), "SSH: simple-host");
-        assert!(state.items[0].description.is_none());
-    }
-
-    #[test]
-    fn test_add_host_with_partial_details() {
-        let mut state = SshState::new();
-        state.add_host_item("partial", Some("example.com".to_string()), None, None);
-
-        assert_eq!(state.items.len(), 1);
-        let desc = state.items[0].description.as_ref().unwrap();
-        assert_eq!(desc.as_str(), "example.com");
-    }
-
-    #[test]
-    fn test_items_have_icons() {
-        let mut state = SshState::new();
-        state.add_host_item("test", None, None, None);
-
-        assert!(state.items[0].icon.is_some());
-        assert_eq!(state.items[0].icon.as_ref().unwrap().as_str(), PROVIDER_ICON);
-    }
-
-    #[test]
-    fn test_items_have_keywords() {
-        let mut state = SshState::new();
-        state.add_host_item("test", None, None, None);
-
-        assert!(!state.items[0].keywords.is_empty());
-        let keywords: Vec<&str> = state.items[0].keywords.iter().map(|s| s.as_str()).collect();
-        assert!(keywords.contains(&"ssh"));
-    }
-}

crates/owlry-plugin-system/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "owlry-plugin-system"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "System plugin for owlry - power and session management commands"
-keywords = ["owlry", "plugin", "system", "power"]
-categories = ["os"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"

crates/owlry-plugin-system/src/lib.rs

@@ -1,254 +0,0 @@
-//! System Plugin for Owlry
-//!
-//! A static provider that provides system power and session management commands.
-//!
-//! Commands:
-//! - Shutdown - Power off the system
-//! - Reboot - Restart the system
-//! - Reboot into BIOS - Restart into UEFI/BIOS setup
-//! - Suspend - Suspend to RAM
-//! - Hibernate - Suspend to disk
-//! - Lock Screen - Lock the session
-//! - Log Out - End the current session
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-
-// Plugin metadata
-const PLUGIN_ID: &str = "system";
-const PLUGIN_NAME: &str = "System";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Power and session management commands";
-
-// Provider metadata
-const PROVIDER_ID: &str = "system";
-const PROVIDER_NAME: &str = "System";
-const PROVIDER_PREFIX: &str = ":sys";
-const PROVIDER_ICON: &str = "system-shutdown";
-const PROVIDER_TYPE_ID: &str = "system";
-
-/// System provider state - holds cached items
-struct SystemState {
-    items: Vec<PluginItem>,
-}
-
-impl SystemState {
-    fn new() -> Self {
-        Self { items: Vec::new() }
-    }
-
-    fn load_commands(&mut self) {
-        self.items.clear();
-
-        // Define system commands
-        // Format: (id, name, description, icon, command)
-        let commands: &[(&str, &str, &str, &str, &str)] = &[
-            (
-                "system:shutdown",
-                "Shutdown",
-                "Power off the system",
-                "system-shutdown",
-                "systemctl poweroff",
-            ),
-            (
-                "system:reboot",
-                "Reboot",
-                "Restart the system",
-                "system-reboot",
-                "systemctl reboot",
-            ),
-            (
-                "system:reboot-bios",
-                "Reboot into BIOS",
-                "Restart into UEFI/BIOS setup",
-                "system-reboot",
-                "systemctl reboot --firmware-setup",
-            ),
-            (
-                "system:suspend",
-                "Suspend",
-                "Suspend to RAM",
-                "system-suspend",
-                "systemctl suspend",
-            ),
-            (
-                "system:hibernate",
-                "Hibernate",
-                "Suspend to disk",
-                "system-suspend-hibernate",
-                "systemctl hibernate",
-            ),
-            (
-                "system:lock",
-                "Lock Screen",
-                "Lock the session",
-                "system-lock-screen",
-                "loginctl lock-session",
-            ),
-            (
-                "system:logout",
-                "Log Out",
-                "End the current session",
-                "system-log-out",
-                "loginctl terminate-session self",
-            ),
-        ];
-
-        for (id, name, description, icon, command) in commands {
-            self.items.push(
-                PluginItem::new(*id, *name, *command)
-                    .with_description(*description)
-                    .with_icon(*icon)
-                    .with_keywords(vec!["power".to_string(), "system".to_string()]),
-            );
-        }
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 0, // Static: use frecency ordering
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(SystemState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<SystemState>
-    let state = unsafe { &mut *(handle.ptr as *mut SystemState) };
-
-    // Load/reload commands
-    state.load_commands();
-
-    // Return items
-    state.items.to_vec().into()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, _query: RStr<'_>) -> RVec<PluginItem> {
-    // Static provider - query is handled by the core using cached items
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<SystemState>
-        unsafe {
-            handle.drop_as::<SystemState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_system_state_new() {
-        let state = SystemState::new();
-        assert!(state.items.is_empty());
-    }
-
-    #[test]
-    fn test_system_commands_loaded() {
-        let mut state = SystemState::new();
-        state.load_commands();
-
-        assert!(state.items.len() >= 6);
-
-        // Check for specific commands
-        let names: Vec<&str> = state.items.iter().map(|i| i.name.as_str()).collect();
-        assert!(names.contains(&"Shutdown"));
-        assert!(names.contains(&"Reboot"));
-        assert!(names.contains(&"Suspend"));
-        assert!(names.contains(&"Lock Screen"));
-        assert!(names.contains(&"Log Out"));
-    }
-
-    #[test]
-    fn test_reboot_bios_command() {
-        let mut state = SystemState::new();
-        state.load_commands();
-
-        let bios_cmd = state
-            .items
-            .iter()
-            .find(|i| i.name.as_str() == "Reboot into BIOS")
-            .expect("Reboot into BIOS should exist");
-
-        assert_eq!(bios_cmd.command.as_str(), "systemctl reboot --firmware-setup");
-    }
-
-    #[test]
-    fn test_commands_have_icons() {
-        let mut state = SystemState::new();
-        state.load_commands();
-
-        for item in &state.items {
-            assert!(
-                item.icon.is_some(),
-                "Item '{}' should have an icon",
-                item.name.as_str()
-            );
-        }
-    }
-
-    #[test]
-    fn test_commands_have_descriptions() {
-        let mut state = SystemState::new();
-        state.load_commands();
-
-        for item in &state.items {
-            assert!(
-                item.description.is_some(),
-                "Item '{}' should have a description",
-                item.name.as_str()
-            );
-        }
-    }
-}

crates/owlry-plugin-systemd/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "owlry-plugin-systemd"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "systemd user services plugin for owlry - list and control user-level systemd services"
-keywords = ["owlry", "plugin", "systemd", "services"]
-categories = ["os"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"

crates/owlry-plugin-systemd/src/lib.rs

@@ -1,457 +0,0 @@
-//! systemd User Services Plugin for Owlry
-//!
-//! Lists and controls systemd user-level services.
-//! Uses `systemctl --user` commands to interact with services.
-//!
-//! Each service item opens a submenu with actions like:
-//! - Start/Stop/Restart/Reload/Kill
-//! - Enable/Disable on startup
-//! - View status and journal logs
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-use std::process::Command;
-
-// Plugin metadata
-const PLUGIN_ID: &str = "systemd";
-const PLUGIN_NAME: &str = "systemd Services";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "List and control systemd user services";
-
-// Provider metadata
-const PROVIDER_ID: &str = "systemd";
-const PROVIDER_NAME: &str = "User Units";
-const PROVIDER_PREFIX: &str = ":uuctl";
-const PROVIDER_ICON: &str = "system-run";
-const PROVIDER_TYPE_ID: &str = "uuctl";
-
-/// systemd provider state
-struct SystemdState {
-    items: Vec<PluginItem>,
-}
-
-impl SystemdState {
-    fn new() -> Self {
-        let mut state = Self { items: Vec::new() };
-        state.refresh();
-        state
-    }
-
-    fn refresh(&mut self) {
-        self.items.clear();
-
-        if !Self::systemctl_available() {
-            return;
-        }
-
-        // List all user services (both running and available)
-        let output = match Command::new("systemctl")
-            .args([
-                "--user",
-                "list-units",
-                "--type=service",
-                "--all",
-                "--no-legend",
-                "--no-pager",
-            ])
-            .output()
-        {
-            Ok(o) if o.status.success() => o,
-            _ => return,
-        };
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        self.items = Self::parse_systemctl_output(&stdout);
-
-        // Sort by name
-        self.items.sort_by(|a, b| a.name.as_str().cmp(b.name.as_str()));
-    }
-
-    fn systemctl_available() -> bool {
-        Command::new("systemctl")
-            .args(["--user", "--version"])
-            .output()
-            .map(|o| o.status.success())
-            .unwrap_or(false)
-    }
-
-    fn parse_systemctl_output(output: &str) -> Vec<PluginItem> {
-        let mut items = Vec::new();
-
-        for line in output.lines() {
-            let line = line.trim();
-            if line.is_empty() {
-                continue;
-            }
-
-            // Parse systemctl output - handle variable whitespace
-            // Format: UNIT LOAD ACTIVE SUB DESCRIPTION...
-            let mut parts = line.split_whitespace();
-
-            let unit_name = match parts.next() {
-                Some(u) => u,
-                None => continue,
-            };
-
-            // Skip if not a proper service name
-            if !unit_name.ends_with(".service") {
-                continue;
-            }
-
-            let _load_state = parts.next().unwrap_or("");
-            let active_state = parts.next().unwrap_or("");
-            let sub_state = parts.next().unwrap_or("");
-            let description: String = parts.collect::<Vec<_>>().join(" ");
-
-            // Create a clean display name
-            let display_name = unit_name
-                .trim_end_matches(".service")
-                .replace("app-", "")
-                .replace("@autostart", "")
-                .replace("\\x2d", "-");
-
-            let is_active = active_state == "active";
-            let status_icon = if is_active { "●" } else { "○" };
-
-            let status_desc = if description.is_empty() {
-                format!("{} {} ({})", status_icon, sub_state, active_state)
-            } else {
-                format!("{} {} ({})", status_icon, description, sub_state)
-            };
-
-            // Store service info in the command field as encoded data
-            // Format: SUBMENU:type_id:data where data is "unit_name:is_active"
-            let submenu_data = format!("SUBMENU:uuctl:{}:{}", unit_name, is_active);
-
-            let icon = if is_active {
-                "emblem-ok-symbolic"
-            } else {
-                "emblem-pause-symbolic"
-            };
-
-            items.push(
-                PluginItem::new(
-                    format!("systemd:service:{}", unit_name),
-                    display_name,
-                    submenu_data,
-                )
-                .with_description(status_desc)
-                .with_icon(icon)
-                .with_keywords(vec!["systemd".to_string(), "service".to_string()]),
-            );
-        }
-
-        items
-    }
-}
-
-// ============================================================================
-// Submenu Action Generation (exported for core to use)
-// ============================================================================
-
-/// Generate submenu actions for a given service
-/// This function is called by the core when a service is selected
-pub fn actions_for_service(unit_name: &str, display_name: &str, is_active: bool) -> Vec<PluginItem> {
-    let mut actions = Vec::new();
-
-    if is_active {
-        actions.push(
-            PluginItem::new(
-                format!("systemd:restart:{}", unit_name),
-                "↻ Restart",
-                format!("systemctl --user restart {}", unit_name),
-            )
-            .with_description(format!("Restart {}", display_name))
-            .with_icon("view-refresh")
-            .with_keywords(vec!["systemd".to_string(), "service".to_string()]),
-        );
-
-        actions.push(
-            PluginItem::new(
-                format!("systemd:stop:{}", unit_name),
-                "■ Stop",
-                format!("systemctl --user stop {}", unit_name),
-            )
-            .with_description(format!("Stop {}", display_name))
-            .with_icon("process-stop")
-            .with_keywords(vec!["systemd".to_string(), "service".to_string()]),
-        );
-
-        actions.push(
-            PluginItem::new(
-                format!("systemd:reload:{}", unit_name),
-                "⟳ Reload",
-                format!("systemctl --user reload {}", unit_name),
-            )
-            .with_description(format!("Reload {} configuration", display_name))
-            .with_icon("view-refresh")
-            .with_keywords(vec!["systemd".to_string(), "service".to_string()]),
-        );
-
-        actions.push(
-            PluginItem::new(
-                format!("systemd:kill:{}", unit_name),
-                "✗ Kill",
-                format!("systemctl --user kill {}", unit_name),
-            )
-            .with_description(format!("Force kill {}", display_name))
-            .with_icon("edit-delete")
-            .with_keywords(vec!["systemd".to_string(), "service".to_string()]),
-        );
-    } else {
-        actions.push(
-            PluginItem::new(
-                format!("systemd:start:{}", unit_name),
-                "▶ Start",
-                format!("systemctl --user start {}", unit_name),
-            )
-            .with_description(format!("Start {}", display_name))
-            .with_icon("media-playback-start")
-            .with_keywords(vec!["systemd".to_string(), "service".to_string()]),
-        );
-    }
-
-    // Always available actions
-    actions.push(
-        PluginItem::new(
-            format!("systemd:status:{}", unit_name),
-            "ℹ Status",
-            format!("systemctl --user status {}", unit_name),
-        )
-        .with_description(format!("Show {} status", display_name))
-        .with_icon("dialog-information")
-        .with_keywords(vec!["systemd".to_string(), "service".to_string()])
-        .with_terminal(true),
-    );
-
-    actions.push(
-        PluginItem::new(
-            format!("systemd:journal:{}", unit_name),
-            "📋 Journal",
-            format!("journalctl --user -u {} -f", unit_name),
-        )
-        .with_description(format!("Show {} logs", display_name))
-        .with_icon("utilities-system-monitor")
-        .with_keywords(vec!["systemd".to_string(), "service".to_string()])
-        .with_terminal(true),
-    );
-
-    actions.push(
-        PluginItem::new(
-            format!("systemd:enable:{}", unit_name),
-            "⊕ Enable",
-            format!("systemctl --user enable {}", unit_name),
-        )
-        .with_description(format!("Enable {} on startup", display_name))
-        .with_icon("emblem-default")
-        .with_keywords(vec!["systemd".to_string(), "service".to_string()]),
-    );
-
-    actions.push(
-        PluginItem::new(
-            format!("systemd:disable:{}", unit_name),
-            "⊖ Disable",
-            format!("systemctl --user disable {}", unit_name),
-        )
-        .with_description(format!("Disable {} on startup", display_name))
-        .with_icon("emblem-unreadable")
-        .with_keywords(vec!["systemd".to_string(), "service".to_string()]),
-    );
-
-    actions
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 0, // Static: use frecency ordering
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(SystemdState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<SystemdState>
-    let state = unsafe { &mut *(handle.ptr as *mut SystemdState) };
-
-    state.refresh();
-    state.items.clone().into()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, query: RStr<'_>) -> RVec<PluginItem> {
-    let query_str = query.as_str();
-
-    // Handle submenu action requests: ?SUBMENU:unit.service:is_active
-    if let Some(data) = query_str.strip_prefix("?SUBMENU:") {
-        // Parse data format: "unit_name:is_active"
-        let parts: Vec<&str> = data.splitn(2, ':').collect();
-        if parts.len() >= 2 {
-            let unit_name = parts[0];
-            let is_active = parts[1] == "true";
-            let display_name = unit_name
-                .trim_end_matches(".service")
-                .replace("app-", "")
-                .replace("@autostart", "")
-                .replace("\\x2d", "-");
-
-            return actions_for_service(unit_name, &display_name, is_active).into();
-        } else if !data.is_empty() {
-            // Fallback: just unit name, assume not active
-            let display_name = data
-                .trim_end_matches(".service")
-                .replace("app-", "")
-                .replace("@autostart", "")
-                .replace("\\x2d", "-");
-            return actions_for_service(data, &display_name, false).into();
-        }
-    }
-
-    // Static provider - normal queries not used
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<SystemdState>
-        unsafe {
-            handle.drop_as::<SystemdState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_systemctl_output() {
-        let output = r#"
-foo.service                          loaded active running Foo Service
-bar.service                          loaded inactive dead Bar Service
-baz@autostart.service               loaded active running Baz App
-"#;
-        let items = SystemdState::parse_systemctl_output(output);
-        assert_eq!(items.len(), 3);
-
-        // Check first item
-        assert_eq!(items[0].name.as_str(), "foo");
-        assert!(items[0].command.as_str().contains("SUBMENU:uuctl:foo.service:true"));
-
-        // Check second item (inactive)
-        assert_eq!(items[1].name.as_str(), "bar");
-        assert!(items[1].command.as_str().contains("SUBMENU:uuctl:bar.service:false"));
-
-        // Check third item (cleaned name)
-        assert_eq!(items[2].name.as_str(), "baz");
-    }
-
-    #[test]
-    fn test_actions_for_active_service() {
-        let actions = actions_for_service("test.service", "Test", true);
-
-        // Active services should have restart, stop, reload, kill + common actions
-        let action_ids: Vec<_> = actions.iter().map(|a| a.id.as_str()).collect();
-        assert!(action_ids.contains(&"systemd:restart:test.service"));
-        assert!(action_ids.contains(&"systemd:stop:test.service"));
-        assert!(action_ids.contains(&"systemd:status:test.service"));
-        assert!(!action_ids.contains(&"systemd:start:test.service")); // Not for active
-    }
-
-    #[test]
-    fn test_actions_for_inactive_service() {
-        let actions = actions_for_service("test.service", "Test", false);
-
-        // Inactive services should have start + common actions
-        let action_ids: Vec<_> = actions.iter().map(|a| a.id.as_str()).collect();
-        assert!(action_ids.contains(&"systemd:start:test.service"));
-        assert!(action_ids.contains(&"systemd:status:test.service"));
-        assert!(!action_ids.contains(&"systemd:stop:test.service")); // Not for inactive
-    }
-
-    #[test]
-    fn test_terminal_actions() {
-        let actions = actions_for_service("test.service", "Test", true);
-
-        // Status and journal should have terminal=true
-        for action in &actions {
-            let id = action.id.as_str();
-            if id.contains(":status:") || id.contains(":journal:") {
-                assert!(action.terminal, "Action {} should have terminal=true", id);
-            }
-        }
-    }
-
-    #[test]
-    fn test_submenu_query() {
-        // Test that provider_query handles ?SUBMENU: queries correctly
-        let handle = ProviderHandle { ptr: std::ptr::null_mut() };
-
-        // Query for active service
-        let query = RStr::from_str("?SUBMENU:test.service:true");
-        let actions = provider_query(handle, query);
-        assert!(!actions.is_empty(), "Should return actions for submenu query");
-
-        // Should have restart action for active service
-        let has_restart = actions.iter().any(|a| a.id.as_str().contains(":restart:"));
-        assert!(has_restart, "Active service should have restart action");
-
-        // Query for inactive service
-        let query = RStr::from_str("?SUBMENU:test.service:false");
-        let actions = provider_query(handle, query);
-        assert!(!actions.is_empty(), "Should return actions for submenu query");
-
-        // Should have start action for inactive service
-        let has_start = actions.iter().any(|a| a.id.as_str().contains(":start:"));
-        assert!(has_start, "Inactive service should have start action");
-
-        // Normal query should return empty
-        let query = RStr::from_str("some search");
-        let actions = provider_query(handle, query);
-        assert!(actions.is_empty(), "Normal query should return empty");
-    }
-}

crates/owlry-plugin-weather/Cargo.toml

@@ -1,33 +0,0 @@
-[package]
-name = "owlry-plugin-weather"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Weather widget plugin for owlry - shows current weather with multiple API support"
-keywords = ["owlry", "plugin", "weather", "widget"]
-categories = ["gui"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"
-
-# HTTP client for weather API requests
-reqwest = { version = "0.12", features = ["blocking", "json"] }
-
-# JSON parsing for API responses
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-
-# TOML config parsing
-toml = "0.8"
-
-# XDG directories for cache persistence
-dirs = "5.0"

crates/owlry-plugin-weather/src/lib.rs

@@ -1,754 +0,0 @@
-//! Weather Widget Plugin for Owlry
-//!
-//! Shows current weather with support for multiple APIs:
-//! - wttr.in (default, no API key required)
-//! - OpenWeatherMap (requires API key)
-//! - Open-Meteo (no API key required)
-//!
-//! Weather data is cached for 15 minutes.
-//!
-//! ## Configuration
-//!
-//! Configure via `~/.config/owlry/config.toml`:
-//!
-//! ```toml
-//! [plugins.weather]
-//! provider = "wttr.in"  # or: openweathermap, open-meteo
-//! location = "Berlin"   # city name or "lat,lon"
-//! # api_key = "..."     # Required for OpenWeatherMap
-//! ```
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-use serde::{Deserialize, Serialize};
-use std::fs;
-use std::path::PathBuf;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
-
-// Plugin metadata
-const PLUGIN_ID: &str = "weather";
-const PLUGIN_NAME: &str = "Weather";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Weather widget with multiple API support";
-
-// Provider metadata
-const PROVIDER_ID: &str = "weather";
-const PROVIDER_NAME: &str = "Weather";
-const PROVIDER_ICON: &str = "weather-clear";
-const PROVIDER_TYPE_ID: &str = "weather";
-
-// Timing constants
-const CACHE_DURATION_SECS: u64 = 900; // 15 minutes
-const REQUEST_TIMEOUT: Duration = Duration::from_secs(15);
-const USER_AGENT: &str = "owlry-launcher/0.3";
-
-#[derive(Debug, Clone, PartialEq)]
-enum WeatherProviderType {
-    WttrIn,
-    OpenWeatherMap,
-    OpenMeteo,
-}
-
-impl std::str::FromStr for WeatherProviderType {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "wttr.in" | "wttr" | "wttrin" => Ok(Self::WttrIn),
-            "openweathermap" | "owm" => Ok(Self::OpenWeatherMap),
-            "open-meteo" | "openmeteo" | "meteo" => Ok(Self::OpenMeteo),
-            _ => Err(format!("Unknown weather provider: {}", s)),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-struct WeatherConfig {
-    provider: WeatherProviderType,
-    api_key: Option<String>,
-    location: String,
-}
-
-impl WeatherConfig {
-    /// Load config from ~/.config/owlry/config.toml
-    ///
-    /// Reads from [plugins.weather] section, with fallback to [providers] for compatibility.
-    fn load() -> Self {
-        let config_path = dirs::config_dir()
-            .map(|d| d.join("owlry").join("config.toml"));
-
-        let config_content = config_path
-            .and_then(|p| fs::read_to_string(p).ok());
-
-        if let Some(content) = config_content
-            && let Ok(toml) = content.parse::<toml::Table>()
-        {
-            // Try [plugins.weather] first (new format)
-            if let Some(plugins) = toml.get("plugins").and_then(|v| v.as_table())
-                && let Some(weather) = plugins.get("weather").and_then(|v| v.as_table())
-            {
-                return Self::from_toml_table(weather);
-            }
-
-            // Fallback to [providers] section (old format)
-            if let Some(providers) = toml.get("providers").and_then(|v| v.as_table()) {
-                let provider_str = providers
-                    .get("weather_provider")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("wttr.in");
-
-                let provider = provider_str.parse().unwrap_or(WeatherProviderType::WttrIn);
-
-                let api_key = providers
-                    .get("weather_api_key")
-                    .and_then(|v| v.as_str())
-                    .map(String::from);
-
-                let location = providers
-                    .get("weather_location")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("")
-                    .to_string();
-
-                return Self {
-                    provider,
-                    api_key,
-                    location,
-                };
-            }
-        }
-
-        // Default config
-        Self {
-            provider: WeatherProviderType::WttrIn,
-            api_key: None,
-            location: String::new(),
-        }
-    }
-
-    /// Parse config from a TOML table
-    fn from_toml_table(table: &toml::Table) -> Self {
-        let provider_str = table
-            .get("provider")
-            .and_then(|v| v.as_str())
-            .unwrap_or("wttr.in");
-
-        let provider = provider_str.parse().unwrap_or(WeatherProviderType::WttrIn);
-
-        let api_key = table
-            .get("api_key")
-            .and_then(|v| v.as_str())
-            .map(String::from);
-
-        let location = table
-            .get("location")
-            .and_then(|v| v.as_str())
-            .unwrap_or("")
-            .to_string();
-
-        Self {
-            provider,
-            api_key,
-            location,
-        }
-    }
-}
-
-/// Cached weather data (persisted to disk)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct WeatherData {
-    temperature: f32,
-    feels_like: Option<f32>,
-    condition: String,
-    humidity: Option<u8>,
-    wind_speed: Option<f32>,
-    icon: String,
-    location: String,
-}
-
-/// Persistent cache structure (saved to ~/.local/share/owlry/weather_cache.json)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct WeatherCache {
-    last_fetch_epoch: u64,
-    data: WeatherData,
-}
-
-/// Weather provider state
-struct WeatherState {
-    items: Vec<PluginItem>,
-    config: WeatherConfig,
-    last_fetch_epoch: u64,
-    cached_data: Option<WeatherData>,
-}
-
-impl WeatherState {
-    fn new() -> Self {
-        Self::with_config(WeatherConfig::load())
-    }
-
-    fn with_config(config: WeatherConfig) -> Self {
-        // Load cached weather from disk if available
-        // This prevents blocking HTTP requests on every app open
-        let (last_fetch_epoch, cached_data) = Self::load_cache()
-            .map(|c| (c.last_fetch_epoch, Some(c.data)))
-            .unwrap_or((0, None));
-
-        Self {
-            items: Vec::new(),
-            config,
-            last_fetch_epoch,
-            cached_data,
-        }
-    }
-
-    fn data_dir() -> Option<PathBuf> {
-        dirs::data_dir().map(|d| d.join("owlry"))
-    }
-
-    fn cache_path() -> Option<PathBuf> {
-        Self::data_dir().map(|d| d.join("weather_cache.json"))
-    }
-
-    fn load_cache() -> Option<WeatherCache> {
-        let path = Self::cache_path()?;
-        let content = fs::read_to_string(&path).ok()?;
-        serde_json::from_str(&content).ok()
-    }
-
-    fn save_cache(&self) {
-        if let (Some(data_dir), Some(cache_path), Some(data)) =
-            (Self::data_dir(), Self::cache_path(), &self.cached_data)
-        {
-            if fs::create_dir_all(&data_dir).is_err() {
-                return;
-            }
-            let cache = WeatherCache {
-                last_fetch_epoch: self.last_fetch_epoch,
-                data: data.clone(),
-            };
-            if let Ok(json) = serde_json::to_string_pretty(&cache) {
-                let _ = fs::write(&cache_path, json);
-            }
-        }
-    }
-
-    fn now_epoch() -> u64 {
-        SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_secs()
-    }
-
-    fn is_cache_valid(&self) -> bool {
-        if self.last_fetch_epoch == 0 {
-            return false;
-        }
-        let now = Self::now_epoch();
-        now.saturating_sub(self.last_fetch_epoch) < CACHE_DURATION_SECS
-    }
-
-    fn refresh(&mut self) {
-        // Use cache if still valid (works across app restarts)
-        if self.is_cache_valid()
-            && let Some(data) = self.cached_data.clone() {
-                self.generate_items(&data);
-                return;
-            }
-
-        // Fetch new data from API
-        if let Some(data) = self.fetch_weather() {
-            self.cached_data = Some(data.clone());
-            self.last_fetch_epoch = Self::now_epoch();
-            self.save_cache(); // Persist to disk for next app open
-            self.generate_items(&data);
-        } else {
-            // On fetch failure, try to use stale cache if available
-            if let Some(data) = self.cached_data.clone() {
-                self.generate_items(&data);
-            } else {
-                self.items.clear();
-            }
-        }
-    }
-
-    fn fetch_weather(&self) -> Option<WeatherData> {
-        match self.config.provider {
-            WeatherProviderType::WttrIn => self.fetch_wttr_in(),
-            WeatherProviderType::OpenWeatherMap => self.fetch_openweathermap(),
-            WeatherProviderType::OpenMeteo => self.fetch_open_meteo(),
-        }
-    }
-
-    fn fetch_wttr_in(&self) -> Option<WeatherData> {
-        let location = if self.config.location.is_empty() {
-            String::new()
-        } else {
-            self.config.location.clone()
-        };
-
-        let url = format!("https://wttr.in/{}?format=j1", location);
-
-        let client = reqwest::blocking::Client::builder()
-            .timeout(REQUEST_TIMEOUT)
-            .user_agent(USER_AGENT)
-            .build()
-            .ok()?;
-
-        let response = client.get(&url).send().ok()?;
-        let json: WttrInResponse = response.json().ok()?;
-
-        let current = json.current_condition.first()?;
-        let nearest = json.nearest_area.first()?;
-
-        let location_name = nearest
-            .area_name
-            .first()
-            .map(|a| a.value.clone())
-            .unwrap_or_else(|| "Unknown".to_string());
-
-        Some(WeatherData {
-            temperature: current.temp_c.parse().unwrap_or(0.0),
-            feels_like: current.feels_like_c.parse().ok(),
-            condition: current
-                .weather_desc
-                .first()
-                .map(|d| d.value.clone())
-                .unwrap_or_else(|| "Unknown".to_string()),
-            humidity: current.humidity.parse().ok(),
-            wind_speed: current.windspeed_kmph.parse().ok(),
-            icon: Self::wttr_code_to_icon(&current.weather_code),
-            location: location_name,
-        })
-    }
-
-    fn fetch_openweathermap(&self) -> Option<WeatherData> {
-        let api_key = self.config.api_key.as_ref()?;
-        if self.config.location.is_empty() {
-            return None; // OWM requires a location
-        }
-
-        let url = format!(
-            "https://api.openweathermap.org/data/2.5/weather?q={}&appid={}&units=metric",
-            self.config.location, api_key
-        );
-
-        let client = reqwest::blocking::Client::builder()
-            .timeout(REQUEST_TIMEOUT)
-            .build()
-            .ok()?;
-
-        let response = client.get(&url).send().ok()?;
-        let json: OpenWeatherMapResponse = response.json().ok()?;
-
-        let weather = json.weather.first()?;
-
-        Some(WeatherData {
-            temperature: json.main.temp,
-            feels_like: Some(json.main.feels_like),
-            condition: weather.description.clone(),
-            humidity: Some(json.main.humidity),
-            wind_speed: Some(json.wind.speed * 3.6), // m/s to km/h
-            icon: Self::owm_icon_to_freedesktop(&weather.icon),
-            location: json.name,
-        })
-    }
-
-    fn fetch_open_meteo(&self) -> Option<WeatherData> {
-        let (lat, lon, location_name) = self.get_coordinates()?;
-
-        let url = format!(
-            "https://api.open-meteo.com/v1/forecast?latitude={}&longitude={}&current=temperature_2m,relative_humidity_2m,weather_code,wind_speed_10m&timezone=auto",
-            lat, lon
-        );
-
-        let client = reqwest::blocking::Client::builder()
-            .timeout(REQUEST_TIMEOUT)
-            .build()
-            .ok()?;
-
-        let response = client.get(&url).send().ok()?;
-        let json: OpenMeteoResponse = response.json().ok()?;
-
-        let current = json.current;
-
-        Some(WeatherData {
-            temperature: current.temperature_2m,
-            feels_like: None,
-            condition: Self::wmo_code_to_description(current.weather_code),
-            humidity: Some(current.relative_humidity_2m as u8),
-            wind_speed: Some(current.wind_speed_10m),
-            icon: Self::wmo_code_to_icon(current.weather_code),
-            location: location_name,
-        })
-    }
-
-    fn get_coordinates(&self) -> Option<(f64, f64, String)> {
-        let location = &self.config.location;
-
-        // Check if location is already coordinates (lat,lon)
-        if location.contains(',') {
-            let parts: Vec<&str> = location.split(',').collect();
-            if parts.len() == 2
-                && let (Ok(lat), Ok(lon)) = (
-                    parts[0].trim().parse::<f64>(),
-                    parts[1].trim().parse::<f64>(),
-                ) {
-                    return Some((lat, lon, location.clone()));
-                }
-        }
-
-        // Use Open-Meteo geocoding API
-        let url = format!(
-            "https://geocoding-api.open-meteo.com/v1/search?name={}&count=1",
-            location
-        );
-
-        let client = reqwest::blocking::Client::builder()
-            .timeout(REQUEST_TIMEOUT)
-            .build()
-            .ok()?;
-
-        let response = client.get(&url).send().ok()?;
-        let json: GeocodingResponse = response.json().ok()?;
-
-        let result = json.results?.into_iter().next()?;
-        Some((result.latitude, result.longitude, result.name))
-    }
-
-    fn wttr_code_to_icon(code: &str) -> String {
-        match code {
-            "113" => "weather-clear",
-            "116" => "weather-few-clouds",
-            "119" => "weather-overcast",
-            "122" => "weather-overcast",
-            "143" | "248" | "260" => "weather-fog",
-            "176" | "263" | "266" | "293" | "296" | "299" | "302" | "305" | "308" => {
-                "weather-showers"
-            }
-            "179" | "182" | "185" | "227" | "230" | "323" | "326" | "329" | "332" | "335"
-            | "338" | "350" | "368" | "371" | "374" | "377" => "weather-snow",
-            "200" | "386" | "389" | "392" | "395" => "weather-storm",
-            _ => "weather-clear",
-        }
-        .to_string()
-    }
-
-    fn owm_icon_to_freedesktop(icon: &str) -> String {
-        match icon {
-            "01d" | "01n" => "weather-clear",
-            "02d" | "02n" => "weather-few-clouds",
-            "03d" | "03n" | "04d" | "04n" => "weather-overcast",
-            "09d" | "09n" | "10d" | "10n" => "weather-showers",
-            "11d" | "11n" => "weather-storm",
-            "13d" | "13n" => "weather-snow",
-            "50d" | "50n" => "weather-fog",
-            _ => "weather-clear",
-        }
-        .to_string()
-    }
-
-    fn wmo_code_to_description(code: i32) -> String {
-        match code {
-            0 => "Clear sky",
-            1 => "Mainly clear",
-            2 => "Partly cloudy",
-            3 => "Overcast",
-            45 | 48 => "Foggy",
-            51 | 53 | 55 => "Drizzle",
-            61 | 63 | 65 => "Rain",
-            66 | 67 => "Freezing rain",
-            71 | 73 | 75 | 77 => "Snow",
-            80..=82 => "Rain showers",
-            85 | 86 => "Snow showers",
-            95 | 96 | 99 => "Thunderstorm",
-            _ => "Unknown",
-        }
-        .to_string()
-    }
-
-    fn wmo_code_to_icon(code: i32) -> String {
-        match code {
-            0 | 1 => "weather-clear",
-            2 => "weather-few-clouds",
-            3 => "weather-overcast",
-            45 | 48 => "weather-fog",
-            51 | 53 | 55 | 61 | 63 | 65 | 80 | 81 | 82 => "weather-showers",
-            66 | 67 | 71 | 73 | 75 | 77 | 85 | 86 => "weather-snow",
-            95 | 96 | 99 => "weather-storm",
-            _ => "weather-clear",
-        }
-        .to_string()
-    }
-
-    fn icon_to_resource_path(icon: &str) -> String {
-        let weather_icon = if icon.contains("clear") {
-            "wi-day-sunny"
-        } else if icon.contains("few-clouds") {
-            "wi-day-cloudy"
-        } else if icon.contains("overcast") || icon.contains("clouds") {
-            "wi-cloudy"
-        } else if icon.contains("fog") {
-            "wi-fog"
-        } else if icon.contains("showers") || icon.contains("rain") {
-            "wi-rain"
-        } else if icon.contains("snow") {
-            "wi-snow"
-        } else if icon.contains("storm") {
-            "wi-thunderstorm"
-        } else {
-            "wi-thermometer"
-        };
-        format!("/org/owlry/launcher/icons/weather/{}.svg", weather_icon)
-    }
-
-    fn generate_items(&mut self, data: &WeatherData) {
-        self.items.clear();
-
-        let temp_str = format!("{}°C", data.temperature.round() as i32);
-        let name = format!("{} {}", temp_str, data.condition);
-
-        let mut details = vec![data.location.clone()];
-        if let Some(humidity) = data.humidity {
-            details.push(format!("Humidity {}%", humidity));
-        }
-        if let Some(wind) = data.wind_speed {
-            details.push(format!("Wind {} km/h", wind.round() as i32));
-        }
-        if let Some(feels) = data.feels_like
-            && (feels - data.temperature).abs() > 2.0 {
-                details.push(format!("Feels like {}°C", feels.round() as i32));
-            }
-
-        let encoded_location = data.location.replace(' ', "+");
-        let command = format!("xdg-open 'https://wttr.in/{}'", encoded_location);
-
-        self.items.push(
-            PluginItem::new("weather-current", name, command)
-                .with_description(details.join(" | "))
-                .with_icon(Self::icon_to_resource_path(&data.icon))
-                .with_keywords(vec!["weather".to_string(), "widget".to_string()]),
-        );
-    }
-}
-
-// ============================================================================
-// API Response Types
-// ============================================================================
-
-#[derive(Debug, Deserialize)]
-struct WttrInResponse {
-    current_condition: Vec<WttrInCurrent>,
-    nearest_area: Vec<WttrInArea>,
-}
-
-#[derive(Debug, Deserialize)]
-struct WttrInCurrent {
-    #[serde(rename = "temp_C")]
-    temp_c: String,
-    #[serde(rename = "FeelsLikeC")]
-    feels_like_c: String,
-    humidity: String,
-    #[serde(rename = "weatherCode")]
-    weather_code: String,
-    #[serde(rename = "weatherDesc")]
-    weather_desc: Vec<WttrInValue>,
-    #[serde(rename = "windspeedKmph")]
-    windspeed_kmph: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct WttrInValue {
-    value: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct WttrInArea {
-    #[serde(rename = "areaName")]
-    area_name: Vec<WttrInValue>,
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenWeatherMapResponse {
-    main: OwmMain,
-    weather: Vec<OwmWeather>,
-    wind: OwmWind,
-    name: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct OwmMain {
-    temp: f32,
-    feels_like: f32,
-    humidity: u8,
-}
-
-#[derive(Debug, Deserialize)]
-struct OwmWeather {
-    description: String,
-    icon: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct OwmWind {
-    speed: f32,
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenMeteoResponse {
-    current: OpenMeteoCurrent,
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenMeteoCurrent {
-    temperature_2m: f32,
-    relative_humidity_2m: f32,
-    weather_code: i32,
-    wind_speed_10m: f32,
-}
-
-#[derive(Debug, Deserialize)]
-struct GeocodingResponse {
-    results: Option<Vec<GeocodingResult>>,
-}
-
-#[derive(Debug, Deserialize)]
-struct GeocodingResult {
-    name: String,
-    latitude: f64,
-    longitude: f64,
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RNone,
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Static,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Widget,
-        priority: 12000, // Widget: highest priority
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    let state = Box::new(WeatherState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(handle: ProviderHandle) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<WeatherState>
-    let state = unsafe { &mut *(handle.ptr as *mut WeatherState) };
-
-    state.refresh();
-    state.items.clone().into()
-}
-
-extern "C" fn provider_query(_handle: ProviderHandle, _query: RStr<'_>) -> RVec<PluginItem> {
-    // Static provider - query not used, return empty
-    RVec::new()
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<WeatherState>
-        unsafe {
-            handle.drop_as::<WeatherState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_weather_provider_type_from_str() {
-        assert_eq!(
-            "wttr.in".parse::<WeatherProviderType>().unwrap(),
-            WeatherProviderType::WttrIn
-        );
-        assert_eq!(
-            "owm".parse::<WeatherProviderType>().unwrap(),
-            WeatherProviderType::OpenWeatherMap
-        );
-        assert_eq!(
-            "open-meteo".parse::<WeatherProviderType>().unwrap(),
-            WeatherProviderType::OpenMeteo
-        );
-    }
-
-    #[test]
-    fn test_wttr_code_to_icon() {
-        assert_eq!(WeatherState::wttr_code_to_icon("113"), "weather-clear");
-        assert_eq!(WeatherState::wttr_code_to_icon("116"), "weather-few-clouds");
-        assert_eq!(WeatherState::wttr_code_to_icon("176"), "weather-showers");
-        assert_eq!(WeatherState::wttr_code_to_icon("200"), "weather-storm");
-    }
-
-    #[test]
-    fn test_wmo_code_to_description() {
-        assert_eq!(WeatherState::wmo_code_to_description(0), "Clear sky");
-        assert_eq!(WeatherState::wmo_code_to_description(3), "Overcast");
-        assert_eq!(WeatherState::wmo_code_to_description(95), "Thunderstorm");
-    }
-
-    #[test]
-    fn test_icon_to_resource_path() {
-        assert_eq!(
-            WeatherState::icon_to_resource_path("weather-clear"),
-            "/org/owlry/launcher/icons/weather/wi-day-sunny.svg"
-        );
-    }
-
-    #[test]
-    fn test_cache_validity() {
-        let state = WeatherState {
-            items: Vec::new(),
-            config: WeatherConfig {
-                provider: WeatherProviderType::WttrIn,
-                api_key: None,
-                location: String::new(),
-            },
-            last_fetch_epoch: 0,
-            cached_data: None,
-        };
-        assert!(!state.is_cache_valid());
-    }
-}

crates/owlry-plugin-websearch/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "owlry-plugin-websearch"
-version = "0.4.9"
-edition.workspace = true
-rust-version.workspace = true
-license.workspace = true
-repository.workspace = true
-description = "Web search plugin for owlry - search the web with configurable search engines"
-keywords = ["owlry", "plugin", "websearch", "search"]
-categories = ["web-programming"]
-
-[lib]
-crate-type = ["cdylib"]  # Compile as dynamic library (.so)
-
-[dependencies]
-# Plugin API for owlry
-owlry-plugin-api = { path = "../owlry-plugin-api" }
-
-# ABI-stable types (re-exported from owlry-plugin-api, but needed for RString etc)
-abi_stable = "0.11"

crates/owlry-plugin-websearch/src/lib.rs

@@ -1,299 +0,0 @@
-//! Web Search Plugin for Owlry
-//!
-//! A dynamic provider that opens web searches in the browser.
-//! Supports multiple search engines.
-//!
-//! Examples:
-//! - `? rust programming` → Search DuckDuckGo for "rust programming"
-//! - `web rust docs` → Search for "rust docs"
-//! - `search how to rust` → Search for "how to rust"
-
-use abi_stable::std_types::{ROption, RStr, RString, RVec};
-use owlry_plugin_api::{
-    owlry_plugin, PluginInfo, PluginItem, ProviderHandle, ProviderInfo, ProviderKind,
-    ProviderPosition, API_VERSION,
-};
-
-// Plugin metadata
-const PLUGIN_ID: &str = "websearch";
-const PLUGIN_NAME: &str = "Web Search";
-const PLUGIN_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PLUGIN_DESCRIPTION: &str = "Search the web with configurable search engines";
-
-// Provider metadata
-const PROVIDER_ID: &str = "websearch";
-const PROVIDER_NAME: &str = "Web Search";
-const PROVIDER_PREFIX: &str = "?";
-const PROVIDER_ICON: &str = "web-browser";
-const PROVIDER_TYPE_ID: &str = "websearch";
-
-/// Common search engine URL templates
-/// {query} is replaced with the URL-encoded search term
-const SEARCH_ENGINES: &[(&str, &str)] = &[
-    ("google", "https://www.google.com/search?q={query}"),
-    ("duckduckgo", "https://duckduckgo.com/?q={query}"),
-    ("bing", "https://www.bing.com/search?q={query}"),
-    ("startpage", "https://www.startpage.com/search?q={query}"),
-    ("searxng", "https://searx.be/search?q={query}"),
-    ("brave", "https://search.brave.com/search?q={query}"),
-    ("ecosia", "https://www.ecosia.org/search?q={query}"),
-];
-
-/// Default search engine if not configured
-const DEFAULT_ENGINE: &str = "duckduckgo";
-
-/// Web search provider state
-struct WebSearchState {
-    /// URL template with {query} placeholder
-    url_template: String,
-}
-
-impl WebSearchState {
-    fn new() -> Self {
-        Self::with_engine(DEFAULT_ENGINE)
-    }
-
-    fn with_engine(engine_name: &str) -> Self {
-        let url_template = SEARCH_ENGINES
-            .iter()
-            .find(|(name, _)| *name == engine_name.to_lowercase())
-            .map(|(_, url)| url.to_string())
-            .unwrap_or_else(|| {
-                // If not a known engine, treat it as a custom URL template
-                if engine_name.contains("{query}") {
-                    engine_name.to_string()
-                } else {
-                    // Fall back to default
-                    SEARCH_ENGINES
-                        .iter()
-                        .find(|(name, _)| *name == DEFAULT_ENGINE)
-                        .map(|(_, url)| url.to_string())
-                        .unwrap()
-                }
-            });
-
-        Self { url_template }
-    }
-
-    /// Extract the search term from the query
-    fn extract_search_term(query: &str) -> Option<&str> {
-        let trimmed = query.trim();
-
-        if let Some(rest) = trimmed.strip_prefix("? ") {
-            Some(rest.trim())
-        } else if let Some(rest) = trimmed.strip_prefix("?") {
-            Some(rest.trim())
-        } else if trimmed.to_lowercase().starts_with("web ") {
-            Some(trimmed[4..].trim())
-        } else if trimmed.to_lowercase().starts_with("search ") {
-            Some(trimmed[7..].trim())
-        } else {
-            // In filter mode, accept raw query
-            Some(trimmed)
-        }
-    }
-
-    /// URL-encode a search query
-    fn url_encode(query: &str) -> String {
-        query
-            .chars()
-            .map(|c| match c {
-                ' ' => "+".to_string(),
-                '&' => "%26".to_string(),
-                '=' => "%3D".to_string(),
-                '?' => "%3F".to_string(),
-                '#' => "%23".to_string(),
-                '+' => "%2B".to_string(),
-                '%' => "%25".to_string(),
-                c if c.is_ascii_alphanumeric() || "-_.~".contains(c) => c.to_string(),
-                c => format!("%{:02X}", c as u32),
-            })
-            .collect()
-    }
-
-    /// Build the search URL from a query
-    fn build_search_url(&self, search_term: &str) -> String {
-        let encoded = Self::url_encode(search_term);
-        self.url_template.replace("{query}", &encoded)
-    }
-
-    /// Evaluate a query and return a PluginItem if valid
-    fn evaluate(&self, query: &str) -> Option<PluginItem> {
-        let search_term = Self::extract_search_term(query)?;
-
-        if search_term.is_empty() {
-            return None;
-        }
-
-        let url = self.build_search_url(search_term);
-
-        // Use xdg-open to open the browser
-        let command = format!("xdg-open '{}'", url);
-
-        Some(
-            PluginItem::new(
-                format!("websearch:{}", search_term),
-                format!("Search: {}", search_term),
-                command,
-            )
-            .with_description("Open in browser")
-            .with_icon(PROVIDER_ICON)
-            .with_keywords(vec!["web".to_string(), "search".to_string()]),
-        )
-    }
-}
-
-// ============================================================================
-// Plugin Interface Implementation
-// ============================================================================
-
-extern "C" fn plugin_info() -> PluginInfo {
-    PluginInfo {
-        id: RString::from(PLUGIN_ID),
-        name: RString::from(PLUGIN_NAME),
-        version: RString::from(PLUGIN_VERSION),
-        description: RString::from(PLUGIN_DESCRIPTION),
-        api_version: API_VERSION,
-    }
-}
-
-extern "C" fn plugin_providers() -> RVec<ProviderInfo> {
-    vec![ProviderInfo {
-        id: RString::from(PROVIDER_ID),
-        name: RString::from(PROVIDER_NAME),
-        prefix: ROption::RSome(RString::from(PROVIDER_PREFIX)),
-        icon: RString::from(PROVIDER_ICON),
-        provider_type: ProviderKind::Dynamic,
-        type_id: RString::from(PROVIDER_TYPE_ID),
-        position: ProviderPosition::Normal,
-        priority: 9000, // Dynamic: web search
-    }]
-    .into()
-}
-
-extern "C" fn provider_init(_provider_id: RStr<'_>) -> ProviderHandle {
-    // TODO: Read search engine from config when plugin config is available
-    let state = Box::new(WebSearchState::new());
-    ProviderHandle::from_box(state)
-}
-
-extern "C" fn provider_refresh(_handle: ProviderHandle) -> RVec<PluginItem> {
-    // Dynamic provider - refresh does nothing
-    RVec::new()
-}
-
-extern "C" fn provider_query(handle: ProviderHandle, query: RStr<'_>) -> RVec<PluginItem> {
-    if handle.ptr.is_null() {
-        return RVec::new();
-    }
-
-    // SAFETY: We created this handle from Box<WebSearchState>
-    let state = unsafe { &*(handle.ptr as *const WebSearchState) };
-
-    let query_str = query.as_str();
-
-    match state.evaluate(query_str) {
-        Some(item) => vec![item].into(),
-        None => RVec::new(),
-    }
-}
-
-extern "C" fn provider_drop(handle: ProviderHandle) {
-    if !handle.ptr.is_null() {
-        // SAFETY: We created this handle from Box<WebSearchState>
-        unsafe {
-            handle.drop_as::<WebSearchState>();
-        }
-    }
-}
-
-// Register the plugin vtable
-owlry_plugin! {
-    info: plugin_info,
-    providers: plugin_providers,
-    init: provider_init,
-    refresh: provider_refresh,
-    query: provider_query,
-    drop: provider_drop,
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_extract_search_term() {
-        assert_eq!(
-            WebSearchState::extract_search_term("? rust programming"),
-            Some("rust programming")
-        );
-        assert_eq!(
-            WebSearchState::extract_search_term("?rust"),
-            Some("rust")
-        );
-        assert_eq!(
-            WebSearchState::extract_search_term("web rust docs"),
-            Some("rust docs")
-        );
-        assert_eq!(
-            WebSearchState::extract_search_term("search how to rust"),
-            Some("how to rust")
-        );
-    }
-
-    #[test]
-    fn test_url_encode() {
-        assert_eq!(WebSearchState::url_encode("hello world"), "hello+world");
-        assert_eq!(WebSearchState::url_encode("foo&bar"), "foo%26bar");
-        assert_eq!(WebSearchState::url_encode("a=b"), "a%3Db");
-        assert_eq!(WebSearchState::url_encode("test?query"), "test%3Fquery");
-    }
-
-    #[test]
-    fn test_build_search_url() {
-        let state = WebSearchState::with_engine("duckduckgo");
-        let url = state.build_search_url("rust programming");
-        assert_eq!(url, "https://duckduckgo.com/?q=rust+programming");
-    }
-
-    #[test]
-    fn test_build_search_url_google() {
-        let state = WebSearchState::with_engine("google");
-        let url = state.build_search_url("rust");
-        assert_eq!(url, "https://www.google.com/search?q=rust");
-    }
-
-    #[test]
-    fn test_evaluate() {
-        let state = WebSearchState::new();
-        let item = state.evaluate("? rust docs").unwrap();
-        assert_eq!(item.name.as_str(), "Search: rust docs");
-        assert!(item.command.as_str().contains("xdg-open"));
-        assert!(item.command.as_str().contains("duckduckgo"));
-    }
-
-    #[test]
-    fn test_evaluate_empty() {
-        let state = WebSearchState::new();
-        assert!(state.evaluate("?").is_none());
-        assert!(state.evaluate("? ").is_none());
-    }
-
-    #[test]
-    fn test_custom_url_template() {
-        let state = WebSearchState::with_engine("https://custom.search/q={query}");
-        let url = state.build_search_url("test");
-        assert_eq!(url, "https://custom.search/q=test");
-    }
-
-    #[test]
-    fn test_fallback_to_default() {
-        let state = WebSearchState::with_engine("nonexistent");
-        let url = state.build_search_url("test");
-        assert!(url.contains("duckduckgo")); // Falls back to default
-    }
-}

crates/owlry-rune/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "owlry-rune"
-version = "0.4.9"
+version = "1.1.1"
 edition = "2024"
 rust-version = "1.90"
 description = "Rune scripting runtime for owlry plugins"
@@ -22,7 +22,7 @@ log = "0.4"
 env_logger = "0.11"
 
 # HTTP client for network API
-reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "json", "blocking"] }
+reqwest = { version = "0.13", default-features = false, features = ["rustls", "json", "blocking"] }
 
 # Serialization
 serde = { version = "1", features = ["derive"] }

crates/owlry-rune/src/api.rs

@@ -2,7 +2,7 @@
 //!
 //! This module provides the `owlry` module that Rune plugins can use.
 
-use rune::{ContextError, Module};
+use rune::{Any, ContextError, Module};
 use std::sync::Mutex;
 
 use owlry_plugin_api::{PluginItem, RString};
@@ -20,9 +20,9 @@ pub struct ProviderRegistration {
 
 /// An item returned by a provider
 ///
-/// Used for converting Rune plugin items to FFI format.
-#[derive(Debug, Clone)]
-#[allow(dead_code)]
+/// Exposed to Rune scripts as `owlry::Item`.
+#[derive(Debug, Clone, Any)]
+#[rune(item = ::owlry)]
 pub struct Item {
     pub id: String,
     pub name: String,
@@ -34,8 +34,42 @@ pub struct Item {
 }
 
 impl Item {
+    /// Constructor exposed to Rune via #[rune::function]
+    #[rune::function(path = Self::new)]
+    pub fn rune_new(id: String, name: String, command: String) -> Self {
+        Self {
+            id,
+            name,
+            command,
+            description: None,
+            icon: None,
+            terminal: false,
+            keywords: Vec::new(),
+        }
+    }
+
+    /// Set description (builder pattern for Rune)
+    #[rune::function]
+    fn description(mut self, desc: String) -> Self {
+        self.description = Some(desc);
+        self
+    }
+
+    /// Set icon (builder pattern for Rune)
+    #[rune::function]
+    fn icon(mut self, icon: String) -> Self {
+        self.icon = Some(icon);
+        self
+    }
+
+    /// Set keywords (builder pattern for Rune)
+    #[rune::function]
+    fn keywords(mut self, keywords: Vec<String>) -> Self {
+        self.keywords = keywords;
+        self
+    }
+
     /// Convert to PluginItem for FFI
-    #[allow(dead_code)]
     pub fn to_plugin_item(&self) -> PluginItem {
         let mut item = PluginItem::new(
             RString::from(self.id.as_str()),
@@ -62,7 +96,14 @@ pub static REGISTRATIONS: Mutex<Vec<ProviderRegistration>> = Mutex::new(Vec::new
 pub fn module() -> Result<Module, ContextError> {
     let mut module = Module::with_crate("owlry")?;
 
-    // Register logging functions using builder pattern
+    // Register Item type with constructor and builder methods
+    module.ty::<Item>()?;
+    module.function_meta(Item::rune_new)?;
+    module.function_meta(Item::description)?;
+    module.function_meta(Item::icon)?;
+    module.function_meta(Item::keywords)?;
+
+    // Register logging functions
     module.function("log_info", log_info).build()?;
     module.function("log_debug", log_debug).build()?;
     module.function("log_warn", log_warn).build()?;

crates/owlry-rune/src/lib.rs

@@ -72,10 +72,14 @@ struct RuntimeState {
 #[repr(C)]
 pub struct RuneRuntimeVTable {
     pub info: extern "C" fn() -> RuntimeInfo,
-    pub init: extern "C" fn(plugins_dir: RStr<'_>) -> RuntimeHandle,
+    pub init: extern "C" fn(plugins_dir: RStr<'_>, owlry_version: RStr<'_>) -> RuntimeHandle,
     pub providers: extern "C" fn(handle: RuntimeHandle) -> RVec<RuneProviderInfo>,
     pub refresh: extern "C" fn(handle: RuntimeHandle, provider_id: RStr<'_>) -> RVec<PluginItem>,
-    pub query: extern "C" fn(handle: RuntimeHandle, provider_id: RStr<'_>, query: RStr<'_>) -> RVec<PluginItem>,
+    pub query: extern "C" fn(
+        handle: RuntimeHandle,
+        provider_id: RStr<'_>,
+        query: RStr<'_>,
+    ) -> RVec<PluginItem>,
     pub drop: extern "C" fn(handle: RuntimeHandle),
 }
 
@@ -90,11 +94,15 @@ extern "C" fn runtime_info() -> RuntimeInfo {
     }
 }
 
-extern "C" fn runtime_init(plugins_dir: RStr<'_>) -> RuntimeHandle {
+extern "C" fn runtime_init(plugins_dir: RStr<'_>, owlry_version: RStr<'_>) -> RuntimeHandle {
     let _ = env_logger::try_init();
+    let _version = owlry_version.as_str();
 
     let plugins_dir = PathBuf::from(plugins_dir.as_str());
-    log::info!("Initializing Rune runtime with plugins from: {}", plugins_dir.display());
+    log::info!(
+        "Initializing Rune runtime with plugins from: {}",
+        plugins_dir.display()
+    );
 
     let mut state = RuntimeState {
         plugins: HashMap::new(),
@@ -113,15 +121,20 @@ extern "C" fn runtime_init(plugins_dir: RStr<'_>) -> RuntimeHandle {
                         type_id: RString::from(reg.type_id.as_str()),
                         default_icon: RString::from(reg.default_icon.as_str()),
                         is_static: reg.is_static,
-                        prefix: reg.prefix.as_ref()
+                        prefix: reg
+                            .prefix
+                            .as_ref()
                             .map(|p| RString::from(p.as_str()))
                             .into(),
                     });
                 }
                 state.plugins.insert(id, plugin);
             }
-            log::info!("Loaded {} Rune plugin(s) with {} provider(s)",
-                      state.plugins.len(), state.providers.len());
+            log::info!(
+                "Loaded {} Rune plugin(s) with {} provider(s)",
+                state.plugins.len(),
+                state.providers.len()
+            );
         }
         Err(e) => {
             log::error!("Failed to discover Rune plugins: {}", e);
@@ -238,7 +251,7 @@ mod tests {
         let plugins_dir = temp.path().to_string_lossy();
 
         // Initialize runtime
-        let handle = runtime_init(RStr::from_str(&plugins_dir));
+        let handle = runtime_init(RStr::from_str(&plugins_dir), RStr::from_str("1.0.0"));
         assert!(!handle.0.is_null());
 
         // Get providers (should be empty with no plugins)

crates/owlry-rune/src/loader.rs

@@ -8,7 +8,7 @@ use rune::{Context, Unit};
 
 use crate::api::{self, ProviderRegistration};
 use crate::manifest::PluginManifest;
-use crate::runtime::{compile_source, create_context, create_vm, SandboxConfig};
+use crate::runtime::{SandboxConfig, compile_source, create_context, create_vm};
 
 use owlry_plugin_api::PluginItem;
 
@@ -29,8 +29,8 @@ impl LoadedPlugin {
     /// Create and initialize a new plugin
     pub fn new(manifest: PluginManifest, path: PathBuf) -> Result<Self, String> {
         let sandbox = SandboxConfig::from_permissions(&manifest.permissions);
-        let context = create_context(&sandbox)
-            .map_err(|e| format!("Failed to create context: {}", e))?;
+        let context =
+            create_context(&sandbox).map_err(|e| format!("Failed to create context: {}", e))?;
 
         let entry_path = path.join(&manifest.plugin.entry);
         if !entry_path.exists() {
@@ -45,23 +45,34 @@ impl LoadedPlugin {
             .map_err(|e| format!("Failed to compile: {}", e))?;
 
         // Run the entry point to register providers
-        let mut vm = create_vm(&context, unit.clone())
-            .map_err(|e| format!("Failed to create VM: {}", e))?;
+        let mut vm =
+            create_vm(&context, unit.clone()).map_err(|e| format!("Failed to create VM: {}", e))?;
 
         // Execute the main function if it exists
         match vm.call(rune::Hash::type_hash(["main"]), ()) {
             Ok(result) => {
                 // Try to complete the execution
-                let _: () = rune::from_value(result)
-                    .unwrap_or(());
+                let _: () = rune::from_value(result).unwrap_or(());
             }
             Err(_) => {
                 // No main function is okay
             }
         }
 
-        // Collect registrations
-        let registrations = api::get_registrations();
+        // Collect registrations — from runtime API or from manifest [[providers]]
+        let mut registrations = api::get_registrations();
+        if registrations.is_empty() && !manifest.providers.is_empty() {
+            for decl in &manifest.providers {
+                registrations.push(ProviderRegistration {
+                    name: decl.id.clone(),
+                    display_name: decl.name.clone(),
+                    type_id: decl.type_id.clone().unwrap_or_else(|| decl.id.clone()),
+                    default_icon: decl.icon.clone().unwrap_or_else(|| "application-x-addon".to_string()),
+                    is_static: decl.provider_type != "dynamic",
+                    prefix: decl.prefix.clone(),
+                });
+            }
+        }
 
         log::info!(
             "Loaded Rune plugin '{}' with {} provider(s)",
@@ -93,16 +104,37 @@ impl LoadedPlugin {
         self.registrations.iter().any(|r| r.name == name)
     }
 
-    /// Refresh a static provider (stub for now)
+    /// Refresh a static provider by calling the Rune `refresh()` function
     pub fn refresh_provider(&mut self, _name: &str) -> Result<Vec<PluginItem>, String> {
-        // TODO: Implement provider refresh by calling Rune function
-        Ok(Vec::new())
+        let mut vm = create_vm(&self.context, self.unit.clone())
+            .map_err(|e| format!("Failed to create VM: {}", e))?;
+
+        let output = vm
+            .call(rune::Hash::type_hash(["refresh"]), ())
+            .map_err(|e| format!("refresh() call failed: {}", e))?;
+
+        let items: Vec<crate::api::Item> = rune::from_value(output)
+            .map_err(|e| format!("Failed to parse refresh() result: {}", e))?;
+
+        Ok(items.iter().map(|i| i.to_plugin_item()).collect())
     }
 
-    /// Query a dynamic provider (stub for now)
-    pub fn query_provider(&mut self, _name: &str, _query: &str) -> Result<Vec<PluginItem>, String> {
-        // TODO: Implement provider query by calling Rune function
-        Ok(Vec::new())
+    /// Query a dynamic provider by calling the Rune `query(q)` function
+    pub fn query_provider(&mut self, _name: &str, query: &str) -> Result<Vec<PluginItem>, String> {
+        let mut vm = create_vm(&self.context, self.unit.clone())
+            .map_err(|e| format!("Failed to create VM: {}", e))?;
+
+        let output = vm
+            .call(
+                rune::Hash::type_hash(["query"]),
+                (query.to_string(),),
+            )
+            .map_err(|e| format!("query() call failed: {}", e))?;
+
+        let items: Vec<crate::api::Item> = rune::from_value(output)
+            .map_err(|e| format!("Failed to parse query() result: {}", e))?;
+
+        Ok(items.iter().map(|i| i.to_plugin_item()).collect())
     }
 }
 
@@ -111,7 +143,10 @@ pub fn discover_rune_plugins(plugins_dir: &Path) -> Result<HashMap<String, Loade
     let mut plugins = HashMap::new();
 
     if !plugins_dir.exists() {
-        log::debug!("Plugins directory does not exist: {}", plugins_dir.display());
+        log::debug!(
+            "Plugins directory does not exist: {}",
+            plugins_dir.display()
+        );
         return Ok(plugins);
     }
 
@@ -135,7 +170,11 @@ pub fn discover_rune_plugins(plugins_dir: &Path) -> Result<HashMap<String, Loade
         let manifest = match PluginManifest::load(&manifest_path) {
             Ok(m) => m,
             Err(e) => {
-                log::warn!("Failed to load manifest at {}: {}", manifest_path.display(), e);
+                log::warn!(
+                    "Failed to load manifest at {}: {}",
+                    manifest_path.display(),
+                    e
+                );
                 continue;
             }
         };

crates/owlry-rune/src/manifest.rs

@@ -11,6 +11,28 @@ pub struct PluginManifest {
     pub provides: PluginProvides,
     #[serde(default)]
     pub permissions: PluginPermissions,
+    /// Provider declarations from [[providers]] sections
+    #[serde(default)]
+    pub providers: Vec<ProviderDecl>,
+}
+
+/// A provider declared in [[providers]] section of plugin.toml
+#[derive(Debug, Clone, Deserialize)]
+pub struct ProviderDecl {
+    pub id: String,
+    pub name: String,
+    #[serde(default)]
+    pub prefix: Option<String>,
+    #[serde(default)]
+    pub icon: Option<String>,
+    #[serde(default = "default_provider_type", rename = "type")]
+    pub provider_type: String,
+    #[serde(default)]
+    pub type_id: Option<String>,
+}
+
+fn default_provider_type() -> String {
+    "static".to_string()
 }
 
 /// Core plugin information
@@ -25,7 +47,7 @@ pub struct PluginInfo {
     pub author: String,
     #[serde(default = "default_owlry_version")]
     pub owlry_version: String,
-    #[serde(default = "default_entry")]
+    #[serde(default = "default_entry", alias = "entry_point")]
     pub entry: String,
 }
 
@@ -34,7 +56,7 @@ fn default_owlry_version() -> String {
 }
 
 fn default_entry() -> String {
-    "init.rn".to_string()
+    "main.rn".to_string()
 }
 
 /// What the plugin provides
@@ -64,10 +86,10 @@ pub struct PluginPermissions {
 impl PluginManifest {
     /// Load manifest from a plugin.toml file
     pub fn load(path: &Path) -> Result<Self, String> {
-        let content = std::fs::read_to_string(path)
-            .map_err(|e| format!("Failed to read manifest: {}", e))?;
-        let manifest: PluginManifest = toml::from_str(&content)
-            .map_err(|e| format!("Failed to parse manifest: {}", e))?;
+        let content =
+            std::fs::read_to_string(path).map_err(|e| format!("Failed to read manifest: {}", e))?;
+        let manifest: PluginManifest =
+            toml::from_str(&content).map_err(|e| format!("Failed to parse manifest: {}", e))?;
         manifest.validate()?;
         Ok(manifest)
     }
@@ -78,7 +100,12 @@ impl PluginManifest {
             return Err("Plugin ID cannot be empty".to_string());
         }
 
-        if !self.plugin.id.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-') {
+        if !self
+            .plugin
+            .id
+            .chars()
+            .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
+        {
             return Err("Plugin ID must be lowercase alphanumeric with hyphens".to_string());
         }
 
@@ -123,7 +150,7 @@ version = "1.0.0"
 "#;
         let manifest: PluginManifest = toml::from_str(toml_str).unwrap();
         assert_eq!(manifest.plugin.id, "test-plugin");
-        assert_eq!(manifest.plugin.entry, "init.rn");
+        assert_eq!(manifest.plugin.entry, "main.rn");
     }
 
     #[test]

crates/owlry-rune/src/runtime.rs

@@ -25,7 +25,6 @@ pub struct SandboxConfig {
     pub allowed_commands: Vec<String>,
 }
 
-
 impl SandboxConfig {
     /// Create sandbox config from plugin permissions
     pub fn from_permissions(permissions: &PluginPermissions) -> Self {
@@ -59,12 +58,9 @@ pub fn create_context(sandbox: &SandboxConfig) -> Result<Context, rune::ContextE
 }
 
 /// Compile Rune source code into a Unit
-pub fn compile_source(
-    context: &Context,
-    source_path: &Path,
-) -> Result<Arc<Unit>, CompileError> {
-    let source_content = std::fs::read_to_string(source_path)
-        .map_err(|e| CompileError::Io(e.to_string()))?;
+pub fn compile_source(context: &Context, source_path: &Path) -> Result<Arc<Unit>, CompileError> {
+    let source_content =
+        std::fs::read_to_string(source_path).map_err(|e| CompileError::Io(e.to_string()))?;
 
     let source_name = source_path
         .file_name()
@@ -73,7 +69,10 @@ pub fn compile_source(
 
     let mut sources = Sources::new();
     sources
-        .insert(Source::new(source_name, &source_content).map_err(|e| CompileError::Compile(e.to_string()))?)
+        .insert(
+            Source::new(source_name, &source_content)
+                .map_err(|e| CompileError::Compile(e.to_string()))?,
+        )
         .map_err(|e| CompileError::Compile(format!("Failed to insert source: {}", e)))?;
 
     let mut diagnostics = Diagnostics::new();
@@ -97,13 +96,11 @@ pub fn compile_source(
 }
 
 /// Create a new Rune VM from compiled unit
-pub fn create_vm(
-    context: &Context,
-    unit: Arc<Unit>,
-) -> Result<Vm, CompileError> {
+pub fn create_vm(context: &Context, unit: Arc<Unit>) -> Result<Vm, CompileError> {
     let runtime = Arc::new(
-        context.runtime()
-            .map_err(|e| CompileError::Compile(format!("Failed to get runtime: {}", e)))?
+        context
+            .runtime()
+            .map_err(|e| CompileError::Compile(format!("Failed to get runtime: {}", e)))?,
     );
     Ok(Vm::new(runtime, unit))
 }

crates/owlry/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "owlry"
-version = "0.4.9"
+version = "1.0.6"
 edition = "2024"
 rust-version = "1.90"
 description = "A lightweight, owl-themed application launcher for Wayland"
@@ -11,8 +11,8 @@ keywords = ["launcher", "wayland", "gtk4", "linux"]
 categories = ["gui"]
 
 [dependencies]
-# Shared plugin API
-owlry-plugin-api = { path = "../owlry-plugin-api" }
+# Core backend library
+owlry-core = { path = "../owlry-core" }
 
 # GTK4 for the UI
 gtk4 = { version = "0.10", features = ["v4_12"] }
@@ -20,59 +20,34 @@ gtk4 = { version = "0.10", features = ["v4_12"] }
 # Layer shell support for Wayland overlay behavior
 gtk4-layer-shell = "0.7"
 
-# Fuzzy matching for search
-fuzzy-matcher = "0.3"
-
-# XDG desktop entry parsing
-freedesktop-desktop-entry = "0.7"
-
-# Directory utilities
-dirs = "5"
-
-# Low-level syscalls for stdin detection
+# Low-level syscalls for stdin detection (dmenu mode)
 libc = "0.2"
 
 # Logging
 log = "0.4"
 env_logger = "0.11"
 
-# Error handling
-thiserror = "2"
-
-# Configuration
+# Configuration (needed for config types used in app.rs/theme.rs)
 serde = { version = "1", features = ["derive"] }
 toml = "0.8"
 
 # CLI argument parsing
 clap = { version = "4", features = ["derive"] }
 
-# Math expression evaluation (for Lua plugins)
-meval = { version = "0.2", optional = true }
-
-# JSON serialization for data persistence
+# JSON serialization (needed by plugin commands in CLI)
 serde_json = "1"
 
-# Date/time for frecency calculations
+# Date/time (needed by plugin commands in CLI)
 chrono = { version = "0.4", features = ["serde"] }
 
-# HTTP client (for Lua plugins)
-reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "json", "blocking"], optional = true }
+# Directory utilities (needed by plugin commands)
+dirs = "5"
 
-# Lua runtime for plugin system (optional - can be loaded dynamically via owlry-lua)
-mlua = { version = "0.10", features = ["lua54", "vendored", "send", "serialize"], optional = true }
-
-# Semantic versioning for plugin compatibility
+# Semantic versioning (needed by plugin commands)
 semver = "1"
 
-# Dynamic library loading for native plugins
-libloading = "0.8"
-
-# Desktop notifications (freedesktop notification spec)
-notify-rust = "4"
-
-[dev-dependencies]
-# Temporary directories for tests
-tempfile = "3"
+# Async oneshot channel (background thread -> main loop)
+futures-channel = "0.3"
 
 [build-dependencies]
 # GResource compilation for bundled icons
@@ -81,7 +56,6 @@ glib-build-tools = "0.20"
 [features]
 default = []
 # Enable verbose debug logging (for development/testing builds)
-dev-logging = []
+dev-logging = ["owlry-core/dev-logging"]
 # Enable built-in Lua runtime (disable to use external owlry-lua package)
-# Includes: mlua, meval (math), reqwest (http)
-lua = ["dep:mlua", "dep:meval", "dep:reqwest"]
+lua = ["owlry-core/lua"]

crates/owlry/src/app.rs

@@ -1,23 +1,20 @@
+use crate::backend::SearchBackend;
 use crate::cli::CliArgs;
-use crate::config::Config;
-use crate::data::FrecencyStore;
-use crate::filter::ProviderFilter;
-use crate::paths;
-use crate::plugins::native_loader::NativePluginLoader;
-#[cfg(feature = "lua")]
-use crate::plugins::PluginManager;
-use crate::providers::native_provider::NativeProvider;
-use crate::providers::Provider;  // For name() method
-use crate::providers::ProviderManager;
+use crate::client::CoreClient;
+use crate::providers::DmenuProvider;
 use crate::theme;
 use crate::ui::MainWindow;
 use gtk4::prelude::*;
-use gtk4::{gio, Application, CssProvider};
+use gtk4::{Application, CssProvider, gio};
 use gtk4_layer_shell::{Edge, Layer, LayerShell};
 use log::{debug, info, warn};
+use owlry_core::config::Config;
+use owlry_core::data::FrecencyStore;
+use owlry_core::filter::ProviderFilter;
+use owlry_core::paths;
+use owlry_core::providers::{Provider, ProviderManager, ProviderType};
 use std::cell::RefCell;
 use std::rc::Rc;
-use std::sync::Arc;
 
 const APP_ID: &str = "org.owlry.launcher";
 
@@ -39,7 +36,7 @@ impl OwlryApp {
 
     pub fn run(&self) -> i32 {
         // Use empty args since clap already parsed our CLI arguments.
-        // This prevents GTK from trying to parse --mode, --providers, etc.
+        // This prevents GTK from trying to parse --mode, --profile, etc.
         self.app.run_with_args(&[] as &[&str]).into()
     }
 
@@ -52,33 +49,69 @@ impl OwlryApp {
 
         let config = Rc::new(RefCell::new(Config::load_or_default()));
 
-        // Load native plugins from /usr/lib/owlry/plugins/
-        let native_providers = Self::load_native_plugins(&config.borrow());
+        // Build backend based on mode
+        let dmenu_mode = DmenuProvider::has_stdin_data();
 
-        // Create provider manager with native plugins
-        #[cfg(feature = "lua")]
-        let mut provider_manager = ProviderManager::with_native_plugins(native_providers);
-        #[cfg(not(feature = "lua"))]
-        let provider_manager = ProviderManager::with_native_plugins(native_providers);
+        let backend = if dmenu_mode {
+            // dmenu mode: local ProviderManager, no daemon
+            let mut dmenu = DmenuProvider::new();
+            dmenu.enable();
+            let core_providers: Vec<Box<dyn Provider>> = vec![Box::new(dmenu)];
+            let provider_manager = ProviderManager::new(core_providers, Vec::new());
+            let frecency = FrecencyStore::load_or_default();
 
-        // Load Lua plugins if enabled (requires lua feature)
-        #[cfg(feature = "lua")]
-        if config.borrow().plugins.enabled {
-            Self::load_lua_plugins(&mut provider_manager, &config.borrow());
-        }
+            SearchBackend::Local {
+                providers: Box::new(provider_manager),
+                frecency,
+            }
+        } else {
+            // Normal mode: connect to daemon via IPC
+            match CoreClient::connect_or_start() {
+                Ok(client) => {
+                    info!("Connected to owlry-core daemon");
+                    SearchBackend::Daemon(crate::backend::DaemonHandle::new(client))
+                }
+                Err(e) => {
+                    warn!(
+                        "Failed to connect to daemon ({}), falling back to local providers",
+                        e
+                    );
+                    Self::create_local_backend(&config.borrow())
+                }
+            }
+        };
 
-        let providers = Rc::new(RefCell::new(provider_manager));
-        let frecency = Rc::new(RefCell::new(FrecencyStore::load_or_default()));
+        let backend = Rc::new(RefCell::new(backend));
 
-        // Create filter from CLI args and config
-        let filter = ProviderFilter::new(
-            args.mode.clone(),
-            args.providers.clone(),
-            &config.borrow().providers,
-        );
+        // Create filter from CLI args, profile, and config
+        let resolved_modes = resolve_modes(args, &config.borrow());
+        let filter = if let Some(modes) = resolved_modes {
+            // CLI --mode or --profile specified explicit modes
+            let provider_types: Vec<ProviderType> = modes
+                .iter()
+                .map(|s| ProviderFilter::mode_string_to_provider_type(s))
+                .collect();
+            if provider_types.len() == 1 {
+                ProviderFilter::new(
+                    Some(provider_types[0].clone()),
+                    None,
+                    &config.borrow().providers,
+                )
+            } else {
+                ProviderFilter::new(None, Some(provider_types), &config.borrow().providers)
+            }
+        } else {
+            ProviderFilter::new(None, None, &config.borrow().providers)
+        };
         let filter = Rc::new(RefCell::new(filter));
 
-        let window = MainWindow::new(app, config.clone(), providers.clone(), frecency.clone(), filter.clone(), args.prompt.clone());
+        let window = MainWindow::new(
+            app,
+            config.clone(),
+            backend.clone(),
+            filter.clone(),
+            args.prompt.clone(),
+        );
 
         // Set up layer shell for Wayland overlay behavior
         window.init_layer_shell();
@@ -102,113 +135,75 @@ impl OwlryApp {
         Self::load_css(&config.borrow());
 
         window.present();
+
+        // Populate results AFTER present() so the window appears immediately
+        window.schedule_initial_results();
     }
 
-    /// Load native (.so) plugins from the system plugins directory
-    /// Returns NativeProvider instances that can be passed to ProviderManager
-    fn load_native_plugins(config: &Config) -> Vec<NativeProvider> {
-        let mut loader = NativePluginLoader::new();
+    /// Create a local backend as fallback when daemon is unavailable.
+    /// Loads native plugins and creates providers locally.
+    fn create_local_backend(config: &Config) -> SearchBackend {
+        use owlry_core::plugins::native_loader::NativePluginLoader;
+        use owlry_core::providers::native_provider::NativeProvider;
+        use owlry_core::providers::{ApplicationProvider, CommandProvider};
+        use std::sync::Arc;
 
-        // Set disabled plugins from config
+        // Load native plugins
+        let mut loader = NativePluginLoader::new();
         loader.set_disabled(config.plugins.disabled_plugins.clone());
 
-        // Discover and load plugins
-        match loader.discover() {
-            Ok(count) => {
-                if count == 0 {
-                    debug!("No native plugins found in {}",
-                           crate::plugins::native_loader::SYSTEM_PLUGINS_DIR);
-                    return Vec::new();
+        let native_providers: Vec<NativeProvider> = match loader.discover() {
+            Ok(count) if count > 0 => {
+                info!("Discovered {} native plugin(s) for local fallback", count);
+                let plugins: Vec<Arc<owlry_core::plugins::native_loader::NativePlugin>> =
+                    loader.into_plugins();
+                let mut providers = Vec::new();
+                for plugin in plugins {
+                    for provider_info in &plugin.providers {
+                        let provider =
+                            NativeProvider::new(Arc::clone(&plugin), provider_info.clone());
+                        providers.push(provider);
+                    }
                 }
-                info!("Discovered {} native plugin(s)", count);
-            }
-            Err(e) => {
-                warn!("Failed to discover native plugins: {}", e);
-                return Vec::new();
-            }
-        }
-
-        // Get all plugins and create providers
-        let plugins: Vec<Arc<crate::plugins::native_loader::NativePlugin>> =
-            loader.into_plugins();
-
-        // Create NativeProvider instances from loaded plugins
-        let mut providers = Vec::new();
-        for plugin in plugins {
-            for provider_info in &plugin.providers {
-                let provider = NativeProvider::new(Arc::clone(&plugin), provider_info.clone());
-                info!("Created native provider: {} ({})", provider.name(), provider.type_id());
-                providers.push(provider);
-            }
-        }
-
-        info!("Loaded {} provider(s) from native plugins", providers.len());
-        providers
-    }
-
-    /// Load Lua plugins from the user plugins directory (requires lua feature)
-    #[cfg(feature = "lua")]
-    fn load_lua_plugins(provider_manager: &mut ProviderManager, config: &Config) {
-        let plugins_dir = match paths::plugins_dir() {
-            Some(dir) => dir,
-            None => {
-                warn!("Could not determine plugins directory");
-                return;
+                providers
             }
+            _ => Vec::new(),
         };
 
-        // Get owlry version from Cargo.toml at compile time
-        let owlry_version = env!("CARGO_PKG_VERSION");
+        let core_providers: Vec<Box<dyn Provider>> = vec![
+            Box::new(ApplicationProvider::new()),
+            Box::new(CommandProvider::new()),
+        ];
 
-        let mut plugin_manager = PluginManager::new(plugins_dir, owlry_version);
+        let provider_manager = ProviderManager::new(core_providers, native_providers);
+        let frecency = FrecencyStore::load_or_default();
 
-        // Set disabled plugins from config
-        plugin_manager.set_disabled(config.plugins.disabled_plugins.clone());
-
-        // Discover plugins
-        match plugin_manager.discover() {
-            Ok(count) => {
-                if count == 0 {
-                    debug!("No Lua plugins found");
-                    return;
-                }
-                info!("Discovered {} Lua plugin(s)", count);
-            }
-            Err(e) => {
-                warn!("Failed to discover Lua plugins: {}", e);
-                return;
-            }
-        }
-
-        // Initialize all plugins (load Lua code)
-        let init_errors = plugin_manager.initialize_all();
-        for error in &init_errors {
-            warn!("Plugin initialization error: {}", error);
-        }
-
-        // Create providers from initialized plugins
-        let plugin_providers = plugin_manager.create_providers();
-        let provider_count = plugin_providers.len();
-
-        // Add plugin providers to the main provider manager
-        provider_manager.add_providers(plugin_providers);
-
-        if provider_count > 0 {
-            info!("Loaded {} provider(s) from Lua plugins", provider_count);
+        SearchBackend::Local {
+            providers: Box::new(provider_manager),
+            frecency,
         }
     }
 
     fn setup_icon_theme() {
-        // Ensure we have icon fallbacks for weather/media icons
-        // These may not exist in all icon themes
         if let Some(display) = gtk4::gdk::Display::default() {
             let icon_theme = gtk4::IconTheme::for_display(&display);
 
-            // Add Adwaita as fallback search path (has weather and media icons)
-            icon_theme.add_search_path("/usr/share/icons/Adwaita");
-            icon_theme.add_search_path("/usr/share/icons/breeze");
+            // If the system icon theme doesn't exist on disk (e.g., set in
+            // gsettings but not installed), GTK falls back to hicolor which
+            // has almost no icons. Detect this and use Adwaita instead.
+            let theme_name = icon_theme.theme_name();
+            let theme_exists = icon_theme
+                .search_path()
+                .iter()
+                .any(|p| p.join(theme_name.as_str()).is_dir());
 
-            debug!("Icon theme search paths configured with Adwaita/breeze fallbacks");
+            if !theme_exists && theme_name != "hicolor" && theme_name != "Adwaita" {
+                info!(
+                    "Icon theme '{}' not found on disk, falling back to Adwaita",
+                    theme_name
+                );
+                icon_theme.set_theme_name(Some("Adwaita"));
+            }
         }
     }
 
@@ -254,16 +249,17 @@ impl OwlryApp {
 
         // 3. Load user's custom stylesheet if exists
         if let Some(custom_path) = paths::custom_style_file()
-            && custom_path.exists() {
-                let custom_provider = CssProvider::new();
-                custom_provider.load_from_path(&custom_path);
-                gtk4::style_context_add_provider_for_display(
-                    &display,
-                    &custom_provider,
-                    gtk4::STYLE_PROVIDER_PRIORITY_USER,
-                );
-                debug!("Loaded custom CSS from {:?}", custom_path);
-            }
+            && custom_path.exists()
+        {
+            let custom_provider = CssProvider::new();
+            custom_provider.load_from_path(&custom_path);
+            gtk4::style_context_add_provider_for_display(
+                &display,
+                &custom_provider,
+                gtk4::STYLE_PROVIDER_PRIORITY_USER,
+            );
+            debug!("Loaded custom CSS from {:?}", custom_path);
+        }
 
         // 4. Inject config variables (highest priority for overrides)
         let vars_css = theme::generate_variables_css(&config.appearance);
@@ -277,3 +273,21 @@ impl OwlryApp {
         debug!("Injected config CSS variables");
     }
 }
+
+/// Resolve which modes to enable based on CLI args and config profiles.
+///
+/// Priority: `--mode` > `--profile` > default (all providers from config).
+/// Returns `None` when no explicit mode selection was made.
+fn resolve_modes(args: &CliArgs, config: &Config) -> Option<Vec<String>> {
+    if let Some(ref mode) = args.mode {
+        return Some(vec![mode.to_string()]);
+    }
+    if let Some(ref profile_name) = args.profile {
+        if let Some(profile) = config.profiles.get(profile_name) {
+            return Some(profile.modes.clone());
+        }
+        eprintln!("Unknown profile: {}", profile_name);
+        std::process::exit(1);
+    }
+    None
+}