# Windy Word (npm · windy-word-mcp)

Control Windy Word voice-to-text from any MCP agent — 60 tools across 12 categories.

- Trust score: 69/100 (medium)
- Change this week: +23
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `windy-word-mcp`: 69/100 (this document), [markdown](https://verifymcp.io/servers/sneakyfree-windy-word-mcp/windy-word-mcp.md), [page](https://verifymcp.io/servers/sneakyfree-windy-word-mcp/windy-word-mcp)

## Channel facts

- Registry: `npm`
- Package: `windy-word-mcp`
- Version: `1.3.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 86/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 73 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 79/100
  - AI-judged instruction clarity (excellent).
  - Tool/resource definitions use about 6432 tokens (~96/item across 67 items; 67 tools + 0 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 23/100
  - Stability observed for 7 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 98% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add sneakyfree-windy-word-mcp -- npx -y windy-word-mcp
```

### Codex

```bash
codex mcp add sneakyfree-windy-word-mcp -- npx -y windy-word-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sneakyfree-windy-word-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "windy-word-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add sneakyfree-windy-word-mcp --command npx --arg -y --arg windy-word-mcp
```

### Hermes

```yaml
mcp_servers:
  sneakyfree-windy-word-mcp:
    command: "npx"
    args: ["-y", "windy-word-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "sneakyfree-windy-word-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "windy-word-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-02 (score 69, +43)

- [security regression] Provenance: unverified → fail
- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [functional improvement] Schema quality: unverified → excellent
- [functional improvement] Stability: unverified → 0.20
- [functional improvement] License: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Maintenance: unverified → pass
- [functional] Licence: MIT

### 2026-08-01 (score 26, +5)

- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] MCP protocol: unverified → pass

### 2026-07-31 (score 21, −7)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 28, −18)

- [security regression] Malware scan: pass → unverified

### 2026-07-27 (score 46)

First indexed and scored.

## MCP tools (67)

### `get_platform` (~55 tokens)

Return OS / arch / distro / display-server / desktop-environment / tool-availability info for the machine running Windy Word. Use this first when diagnosing paste / hotkey issues — the platform determines which strategies and capabilities are valid.

### `list_paste_strategies` (~95 tokens)

List all 12 paste strategies (macOS / Windows / Linux X11 / Linux Wayland) with full capability metadata, a per-strategy availableOnThisMachine flag, the resolved default fallback chain, and a hotkeyCollisionDetected flag indicating whether Mutter or another compositor is eating Windy Word's own paste keystroke (which silently breaks the Ctrl+Shift+V family on Wayland+GNOME).

### `get_active_paste_strategy` (~61 tokens)

Return the currently selected paste strategy, the user-configured fallback chain, and the resolved chain that will actually be tried at paste time. When strategy is "auto", the chain comes from defaultFallbackChain() with hotkey-collision demotion applied.

### `set_paste_strategy` (~117 tokens)

Select a paste strategy. Pass "auto" to use the platform default chain, or a specific strategy name (e.g. "wtype", "ydotool_type", "osascript_cmdv"). Optionally override the fallback chain. Strategy names come from list_paste_strategies.

Input parameters:

- `fallbackChain` (array): Optional override for the fallback order. If omitted, leaves the existing chain.
- `strategy` (string, required): Strategy name (or "auto"). Must match a name returned by list_paste_strategies.

### `test_paste_strategy` (~85 tokens)

WARNING: injects test text ("wtest") into whatever window currently has focus. Use to verify a specific strategy works on this machine. Returns timing + success flag. Have the user focus a known-safe target (e.g. a text editor) before calling.

Input parameters:

- `strategy` (string, required): Strategy name to test. Get the list from list_paste_strategies.

### `run_paste_injection_test` (~205 tokens)

Real end-to-end paste injection test. Spawns a focusable Tk scratchpad target, temporarily flips Mutter's focus-new-windows policy to "strict" so the target auto-grabs focus, fires the requested paste strategy, captures what landed in the target, and returns whether the captured text matches what was sent. SAFE TO RUN — the target is a spawned scratchpad, not the user's active window; the focus-policy flip is reverted after the test. Wayland+GNOME only in v0 (the gsettings focus-policy flip is GNOME-specific). Returns the paste-strategy attempt diagnostic too.

Input parameters:

- `captureSeconds` (integer): How long to keep the Tk target open after firing the paste (default 6s).
- `strategy` (string): Paste strategy to test (default "ydotool_type"). Use list_paste_strategies to discover names.
- `text` (string): Text to inject (default: a unique timestamped marker).

### `auto_paste` (~84 tokens)

Execute the auto-paste flow against an explicit candidate chain. Returns the winning strategy + per-strategy diagnostic data. Useful for stress-testing fallback behavior. WARNING: injects text into the focused window.

Input parameters:

- `candidates` (array): Ordered list of strategies to try. Defaults to defaultFallbackChain().
- `text` (string): Text to paste (defaults to "wtest").

### `get_paste_history` (~71 tokens)

Return the last N paste attempts with diagnostic data: timestamp, text length, content hash (NOT the actual text), strategy chain attempted, winner, target window type. The buffer is in-memory and resets when the app restarts.

Input parameters:

- `limit` (integer): Max entries to return (default 20).

### `clear_paste_history` (~24 tokens)

Reset the in-memory paste history buffer. Useful between stress-test runs.

### `get_paste_target` (~64 tokens)

Detect whether the currently focused window is XWayland or Wayland-native (or unknown). This is what xdotool sees — agents use it to verify their assumptions before picking a strategy, because XWayland targets accept different keystrokes than Wayland-native ones.

### `list_hotkeys` (~45 tokens)

List all current keyboard shortcut bindings, the set of rebindable actions, and the list of accelerators that are reserved (cannot be assigned). Use this before set_hotkey.

### `set_hotkey` (~100 tokens)

Rebind a keyboard shortcut. Action keys: toggleRecording, pasteTranscript, pasteClipboard, showHide, quickTranslate. Accelerator format is Electron-style (e.g. "CommandOrControl+Shift+Space", "Alt+W"). Triggers an immediate re-registration.

Input parameters:

- `accelerator` (string, required): Electron accelerator (e.g. "CommandOrControl+Shift+Space"). Avoid reserved combos.
- `key` (string, required): Which action to rebind.

### `list_models` (~50 tokens)

List available Whisper transcription models (tiny / base / small / medium / large-v3), their on-disk size and accuracy/speed tradeoff, the current selected model, and the WindyTune ladder.

### `set_model` (~78 tokens)

Switch the active transcription model. Hot-reloads the running Python engine over WebSocket if it is currently active — no app restart needed. Model must be in the WindyTune ladder (see list_models).

Input parameters:

- `model` (string, required): Model id (e.g. "tiny", "base", "small", "medium", "large-v3").

### `get_windytune_state` (~60 tokens)

Return WindyTune auto-tune state: whether it is enabled, the current model, the model ladder, switch thresholds, the recent transcription timing history, and the rolling average ratio (used to decide when to climb or descend the ladder).

### `list_installable_dependencies` (~84 tokens)

List the whitelisted system tools that Windy Word can install on this machine to expand its capabilities (e.g. wtype for instant Wayland paste). Returns supported platform check + distro detection + the resolved install command per tool. Always safe to call (no system mutation). v0 supports Linux only — returns supported=false with a friendly explanation on macOS/Windows.

### `install_dependency` (~221 tokens)

Install a missing system tool via the distro package manager wrapped in pkexec. WARNING: this triggers a graphical sudo (polkit) prompt that the user must approve interactively — do not call without telling the user a prompt will appear. The tool must be in Windy Word's whitelist: wtype, ydotool, wl-clipboard, xdotool. Linux only. After a successful install of wtype, re-check list_paste_strategies — wtype will flip to availableOnThisMachine=true and become first-pick in the resolved chain (paste becomes instant on Wayland-native targets). Use dryRun=true to see the command without executing it.

Input parameters:

- `dryRun` (boolean): If true, return the install command that WOULD run without executing it.
- `tool` (string, required): Which tool to install. Constrained to the whitelist. Note: not every tool is installable on every OS (cliclick is macOS-only, the Wayland tools are Linux-only). Use list_installable_dependencies to s…

### `get_install_history` (~74 tokens)

Return the audit log of recent install_dependency attempts on this machine (timestamp, tool, package, exact command, exit code, elapsed ms, whether the tool is on PATH after, stdout/stderr tails). In-memory; resets when Windy Word restarts.

Input parameters:

- `limit` (integer): Max entries (default 20).

### `clear_install_history` (~23 tokens)

Wipe the in-memory install audit log. Useful between test runs.

### `setup_install_polkit_rule` (~228 tokens)

Install or remove the Linux polkit auto-approve rule that lets install_dependency run without prompts. CRITICAL ONE-TIME SETUP for the agent-native install flow on a fresh machine: triggers a single pkexec password prompt for THIS call (the user types their password once); thereafter every install_dependency call for a whitelisted tool (wtype/ydotool/wl-clipboard/xdotool/ffmpeg) runs prompt-free. Uses subject.active so the rule applies to any logged-in user on the machine (not hardcoded to a single account). Linux only — returns 501 on macOS/Windows.

Recommended flow:
  1\. run_diagnostics — see if install_polkit_rule check is warning
  2\. setup_install_polkit_rule({enable: true}) — user types password once
  3\. install_dependency({tool: "wtype"}) — silent install, no prompt

Pass enable=false to remove the rule (also triggers a polkit prompt).

Input parameters:

- `enable` (boolean, required): true to install the rule, false to remove it.

### `install_dependency_async` (~129 tokens)

Fire-and-poll variant of install_dependency. Returns a jobId immediately and runs the install in the background. Use get_install_status to check progress. Useful when the install might take >10 minutes (e.g., compiling from source, large package downloads on slow networks) or when the agent wants to surface a "still installing…" UI without holding a connection open. The whitelist + platform constraints + polkit/sudo flow are identical to install_dependency.

Input parameters:

- `dryRun` (boolean): If true, return the install command without actually running it.
- `tool` (string, required): Which tool to install.

### `get_install_status` (~88 tokens)

Return the current state of an async install job started by install_dependency_async. Status is "running" (still in flight) or "completed" (finished — check result.ok for success). If the job is not found (FIFO-evicted after 50 jobs, or wrong jobId), returns status="unknown".

Input parameters:

- `jobId` (string, required): Job id returned by install_dependency_async.

### `list_install_jobs` (~35 tokens)

List all install jobs currently in memory — both running and recently completed. Useful for dashboards or when an agent forgot a jobId.

### `export_soul_file_to_path` (~183 tokens)

Export the user's entire Windy Word archive (audio + video + transcripts) as a single zip file at the given path. The Forma Animae artifact — Grant's exportable "soul" for use with the Windy Clone digital-twin pipeline or as a portable backup. Includes a manifest.json with stats (file counts, word counts, date range). Refuses to overwrite existing files unless overwrite=true. Creates parent directories as needed. Pairs with the existing export-soul-file IPC the renderer uses via the Soul File button (which opens a save dialog) — this is the path-based variant for agent-driven exports.

Input parameters:

- `outputPath` (string, required): Destination .zip path (e.g. "/home/user/Documents/my-soul-2026-05.zip").
- `overwrite` (boolean): If true, replace existing file. Default false.

### `transcribe_audio_file` (~201 tokens)

Transcribe an audio file at a given path. Accepts any format ffmpeg can read (wav, mp3, m4a, ogg, flac, webm, etc. — auto-detected). Routes through the same Python Whisper engine the Windy Word desktop app uses for live transcripts (no cold start when the engine is warm — WebSocket-routed for sub-second hand-off). Returns transcript text + timing diagnostics (transcribeMs, audioDurationSec, ratio = transcribe/audio, modelUsed). 500MB file cap; 60s ffmpeg ceiling; 120s WS ceiling. Designed for individual files — agents wanting bulk processing should iterate over a directory and call this per file.

Input parameters:

- `language` (string): ISO-639-1 language hint for Whisper (default "en"). Pass "auto" to let the model detect.
- `path` (string, required): Absolute or working-dir-relative path to the audio file.

### `get_sound_effect_state` (~149 tokens)

Return the current sound-effects configuration: per-hook-stage enabled/volume settings (the 6 stages are start, during, stop, process, warning, paste), the active sound pack, master SFX volume, and any per-stage custom sound overrides. The 6 hookStages are always returned even when live state read fails (so agents can show the stage catalog).

\**Phase 1 limitation:** Sound state lives in renderer-side localStorage, not the main electron-store. Reading via webContents.executeJavaScript currently fails (Electron context-isolation) — expect rendererReadable=false with rendererError set. Phase 2 will add a renderer-side IPC bridge in windy-pro to expose live state + writes.

### `set_sound_hook` (~182 tokens)

Configure a single sound-effect hook stage. Hooks are the 6 lifecycle points where Windy Word plays sounds: start (🎬 begin recording), during (🎤 mid-recording chirps), stop (⏹️ end recording), process (⏳ Whisper transcribing), warning (⚠️ approaching session limit), paste (📋 transcript injected). Each hook has enabled (boolean) + volume (0-100 int). Pass any combo of those args — omitted ones are unchanged. Routes through the renderer EffectsEngine and persists via _saveSettings to localStorage.

Input parameters:

- `enabled` (boolean): Mute (false) / unmute (true) this stage.
- `hook` (string, required): Which of the 6 hook stages.
- `volume` (integer): Per-stage volume 0-100. Multiplies with master SFX volume.

### `set_active_sound_pack` (~89 tokens)

Switch the active sound pack. Pack ids come from list_sound_effect_packs — typical built-ins are "_silent", "classic-beep", "soft-chime". Affects all 6 hook stages unless individually overridden via custom-sound assignments. Persisted via EffectsEngine _saveSettings.

Input parameters:

- `packId` (string, required): Pack id (e.g. "classic-beep", "_silent").

### `set_master_sfx_volume` (~80 tokens)

Set the master SFX volume (0-100). Affects every hook stage as a multiplier on per-stage volumes. Persists immediately to localStorage windy_sfxVolume and applies to the live EffectsEngine.sound master.

Input parameters:

- `volume` (integer, required): Master SFX volume 0-100. 0 = silent, 100 = full.

### `set_sound_effect_mode` (~77 tokens)

Switch the EffectsEngine mode: "silent" (no sounds), "classic" (built-in beeps), "surprise" (random selection from a category), "custom" (per-hook user-assigned sounds), "pack" (active pack drives everything). Persisted via _saveSettings.

Input parameters:

- `mode` (string, required)

### `get_widget_state` (~65 tokens)

Return mini-widget (tornado) runtime state via the renderer bridge: whether the WidgetEngine is present, whether the widget is currently visible, and the localStorage tornadoSize value. Complements the catalog-driven set_setting path for tornadoX/tornadoY/tornadoSize/widgetSettings.

### `list_sound_effect_packs` (~118 tokens)

List the sound-effect packs the Windy Word EffectsEngine knows about (_silent, classic-beep, soft-chime, and other built-in synthesized packs). Pairs with the 6 hook stages (start/during/stop/process/warning/paste) to drive per-stage sound assignments.

\**Phase 1 limitation:** Same as get_sound_effect_state — the renderer EffectsEngine isn't globally exposed, so live pack-list queries return ok=false until Phase 2 (renderer-side IPC bridge). The endpoint shape is finalized for forward-compat.

### `detect_hardware` (~98 tokens)

Return system hardware info: totalRAM (GB), freeRAM (GB), cpuModel, cpuCores, platform, arch, gpu (NVIDIA via nvidia-smi on Linux/Windows; Apple Silicon Metal/MPS on macOS arm64; null otherwise), diskFreeGB (homedir partition). Used by Doctor checks and model-selection decisions — bigger models need more RAM, GPU-accelerated paths only fire when gpu != null.

### `get_autostart_status` (~68 tokens)

Check whether Windy Word is configured to auto-launch on user login. Returns {platform, enabled, desktopFile?}. Linux checks for ~/.config/autostart/windy-pro.desktop; macOS/Windows use electron's app.getLoginItemSettings(). Pure read — no state change.

### `set_autostart` (~81 tokens)

Enable or disable Windy Word's auto-launch on user login. Linux writes/removes a .desktop autostart entry; macOS/Windows toggle via Electron's setLoginItemSettings. Returns the resulting state (enabled boolean) so agents can verify the change took.

Input parameters:

- `enable` (boolean, required): true to enable autostart, false to disable.

### `translate_text` (~150 tokens)

Translate text to a target language. Tries the local translation-memory cache first (instant + free); on miss, calls Groq (preferred) or OpenAI via Windy Word's configured key. The TM cache auto-populates from successful calls so repeat translations are free. Source language defaults to "auto" (model detects); only concrete source-lang calls hit the TM. Returns {ok, translation, fromCache, sourceLang, targetLang, engine}.

Input parameters:

- `sourceLang` (string): Source language code or "auto" (default).
- `targetLang` (string, required): Target language code (e.g. "es", "fr", "ja").
- `text` (string, required): Text to translate.

### `lookup_translation_memory` (~87 tokens)

Look up a (text, sourceLang, targetLang) tuple in the local translation-memory cache. Returns {ok, match: {translation, hits} | null}. No external API call — pure local SQLite query.

Input parameters:

- `sourceLang` (string, required): Source language code.
- `targetLang` (string, required): Target language code.
- `text` (string, required): Source text to look up.

### `save_translation_memory` (~103 tokens)

Store a (source, target, sourceLang, targetLang) tuple in the TM cache. Useful when an agent has a known-good translation it wants future lookups to find without re-calling the LLM. Upserts on duplicate keys (increments the hits counter).

Input parameters:

- `source` (string, required): Source text.
- `sourceLang` (string, required): Source language code.
- `target` (string, required): Target translation.
- `targetLang` (string, required): Target language code.

### `get_translation_memory_stats` (~42 tokens)

Return TM cache stats: totalEntries, topPairs (top 10 source→target language pairs by count), recentEntries (last 50 by updated_at).

### `clear_translation_memory` (~27 tokens)

Wipe the entire translation-memory cache. Destructive — confirm with the user before calling.

### `extract_document_text` (~140 tokens)

Extract plain text from a document file at a given path. Supports .txt / .md / .csv (read as UTF-8), .html (strip tags), .pdf (regex scrape — best-effort, may return [PDF text extraction yielded nothing] for image-only PDFs), .docx (xml-strip). Default size cap 5MB; override via maxBytes (up to 20MB). Returns {ok, path, ext, sizeBytes, textLength, text}.

Input parameters:

- `maxBytes` (integer): Max file size to attempt (default 5MB).
- `path` (string, required): Absolute or working-dir-relative file path.

### `save_text_file` (~108 tokens)

Write text content to a file at a given path. Default: refuses to overwrite existing files (returns a 409-shaped error with the existing file size). Pass overwrite=true to replace. Creates parent directories as needed. Returns {ok, path, bytesWritten}.

Input parameters:

- `content` (required): String content, or an object (will be JSON-stringified).
- `overwrite` (boolean): If true, replace existing file. Default false.
- `path` (string, required): Absolute or working-dir-relative target path.

### `list_archive_entries` (~94 tokens)

List archived recording sessions (the user's historical transcripts + linked audio/video). Each entry has an opaque id (use it with read_archive or delete_archive_entry), date, full transcript text, wordCount, engine used, and hasAudio / hasVideo booleans. Newest first. Path information is NOT returned — agents work with the opaque id.

Input parameters:

- `limit` (integer): Cap on entries returned (default 200).

### `get_archive_stats` (~73 tokens)

Return aggregate stats for the user's recording archive: totalFiles, totalSizeMB, days (number of distinct date directories), audioHours, videoHours, totalWords, totalSessions, totalChars. Cached server-side for 30s — responses include `cached` + `cacheAgeSec` so the agent knows freshness.

### `read_archive_entry` (~137 tokens)

Return an archive entry's metadata + optionally the base64 audio or video media bytes. The mediaType parameter selects which stream ("audio" default, or "video"). Pass metadataOnly=true to skip the base64 payload (responses can be MBs otherwise). Returns { ok, present, mimeType, base64 } or { ok, present: false } if the requested media isn't attached to this entry.

Input parameters:

- `id` (string, required): Archive entry id (from list_archive_entries).
- `mediaType` (string): Which media stream (default "audio").
- `metadataOnly` (boolean): If true, skip the base64 media payload.

### `delete_archive_entry` (~71 tokens)

Tear down an archive entry: removes the transcript .md file + linked audio + linked video, all path-confined to the archive folder. Irreversible — confirm with the user before calling. Returns the list of filenames actually deleted.

Input parameters:

- `id` (string, required): Archive entry id (from list_archive_entries).

### `open_archive_folder` (~53 tokens)

Pop the archive root directory in the user's OS file manager. Side-effect on the desktop (opens a Files / Finder / Explorer window). Use when the user asks "show me where my recordings are saved" or similar.

### `list_voice_clones` (~95 tokens)

List all voice clones the user has on this machine. Returns each clone's id, name, duration, created_at, status, plus a hasAudio boolean (no raw audio in the response — use preview_voice_clone to fetch base64 audio for a specific clone). Also returns activeId — which clone is the current TTS default. Use this to answer "what clones does the user have?" without paging through audio bytes.

### `get_active_voice_clone` (~37 tokens)

Return the currently-active voice clone (the one used for TTS playback), or {active: null} if no clone is selected.

### `set_active_voice_clone` (~67 tokens)

Set which voice clone is the active TTS default. Pass id=null to deactivate (no clone — falls back to built-in TTS). The id must match an existing clone (use list_voice_clones to discover ids).

Input parameters:

- `id` (required): Clone id, or null to deactivate.

### `delete_voice_clone` (~71 tokens)

Delete a voice clone (metadata + audio file on disk). If the deleted clone was the active one, activeId is reset to null. Returns the deleted clone's id and name for audit purposes. Irreversible — confirm with the user before calling.

Input parameters:

- `id` (string, required): Clone id to delete.

### `preview_voice_clone` (~94 tokens)

Return a voice clone's metadata, optionally with the base64-encoded audio sample. Pass metadataOnly=true to skip the audio (responses can be several MB otherwise). The mimeType field tells the agent how to interpret audioBase64 (typically audio/webm).

Input parameters:

- `id` (string, required): Clone id.
- `metadataOnly` (boolean): If true, skip the base64 audio payload. Defaults to false (audio included).

### `create_voice_clone_from_path` (~185 tokens)

Create a voice clone from an audio file on disk. Copies the source file into Windy Word's voice-samples directory under a fresh UUID, registers the clone in the local DB, and returns the new clone's metadata (with hasAudio=true). Supported audio extensions: .webm, .wav, .mp3, .ogg, .m4a, .flac. Source file must exist and be readable; the copy itself is path-confined to Windy's voice-samples dir. Use list_voice_clones afterward to see it and set_active_voice_clone to activate.

Input parameters:

- `durationSec` (number): Audio duration in seconds (if known). Optional metadata.
- `name` (string, required): Human-readable name for the clone (e.g. "My Voice 2026-05").
- `sourcePath` (string, required): Path to the source audio file.

### `get_cloud_clone_order_status` (~105 tokens)

Check the status of a Windy Clone cloud-training order — used after submit_voice_clone_to_cloud (Phase 2 — not yet exposed as MCP) to poll for ElevenLabs training completion. Requires the user to be signed in to their Windy account; returns a clean 401-shape error if not. Returns the raw order body from the Windy Clone API.

Input parameters:

- `orderId` (string, required): Order id returned from a previous submit_voice_clone_to_cloud call.

### `list_clone_bundles` (~96 tokens)

List training-bundle catalog — audio/video recordings the user has marked as candidates for voice-clone training. Each entry has bundle_id, name, device info, sync_status, training_ready flag, file size, created_at, and fileExists. Pairs with InstaBio voice-clone ingestion which reads from these bundles. See [[project_instabio_voice_clone_data]] memory for the broader voice-clone training-data contract.

### `run_diagnostics` (~154 tokens)

Run the local Windy Doctor check battery and return a structured report: overall health (healthy / degraded / unhealthy), per-check status (ok / warning / error / not_applicable), severity, what was found, and (for non-ok findings) an actionable remediation step that often references the specific MCP tool to call next (e.g., "install_dependency({tool: \"wtype\"})"). Covers: paste-stack tooling presence, /dev/uinput permissions, ydotoold daemon health, polkit rule installation, Python transcription engine liveness, Mutter hotkey collision. No system mutation — pure read. Use this as the starting point for any "why is paste broken / why is transcription failing" agent flow.

### `list_diagnostic_checks` (~61 tokens)

List the catalog of Windy Doctor diagnostic checks without running them. Returns each check's name, description, and whether it applies to this platform. Useful for agent introspection — understanding what the doctor knows how to look at before kicking off a diagnostic run.

### `cloud_diagnose` (~179 tokens)

Run local diagnostics AND route the findings to the windy-fix-me cloud-relay for LLM-augmented remediation. Returns both the local rule-based findings and the cloud-relay's structured remediation (each entry has rootCause, a specific MCP tool call to invoke, fallback, verification steps). Use this when local run_diagnostics surfaces warnings/errors and you want expert-level fix guidance that knows about platform-specific quirks the local rules don't. Relay endpoint: https://windy-fix-me.windyword.workers.dev/diagnose (override via WINDY_FIX_ME_URL env var on the Windy Word side). May add ~2-3s of latency from the LLM round-trip.

Input parameters:

- `sharedSecret` (string): Optional X-Windy-Fix-Me-Key for relays that require auth. Most public deployments leave this unset.

### `list_settings` (~204 tokens)

List every setting Windy Word exposes as an agent-discoverable, schema-validated path. Returns each setting's dotted path, type, description, allowed values (if enum / range), default, side effects of changing it, restartRequired flag, sensitivity (writable vs readonly), tags, and the current live value. The response also includes availableTags so agents can discover what tag filters exist. Use this as the entry point for any agent setting introspection. Paths outside the catalog are accessible only via the lower-level get_config / set_config tools. Optional `tag` parameter narrows results — e.g. tag="voice-clone" returns just the settings that drive InstaBio voice-clone training behavior, tag="archive" returns archive-related settings, etc.

Input parameters:

- `tag` (string): Optional tag to filter by (voice-clone, archive, transcription, paste, hotkey, ui, geometry, lifecycle, etc). See availableTags in the unfiltered response.

### `describe_setting` (~90 tokens)

Return the full catalog entry for one setting (type / allowed values / description / default / side effects / restartRequired / sensitivity) plus its current value from the live store. Returns an error if the path is not in the catalog — use get_config for paths outside it.

Input parameters:

- `path` (string, required): Dotted path (e.g. "engine.model", "paste.strategy", "hotkeys.toggleRecording").

### `set_setting` (~157 tokens)

Validate and apply a setting change against the catalog. Rejects unknown paths, type mismatches, out-of-range numbers, invalid enum values, malformed accelerators, and attempts to write read-only settings (e.g. license.*). On success, returns the previous + new value, any side effects that fired (e.g. "global shortcuts re-registered", "python engine hot-reload sent"), and whether a restart is required for the change to take full effect. Use set_config to bypass the catalog (low-level, no validation — for paths outside the catalog).

Input parameters:

- `path` (string, required): Dotted path. Get the catalog from list_settings.
- `value` (required): New value. Must match the type the catalog declares for this path.

### `get_config` (~41 tokens)

Return the full electron-store config tree (every setting Windy Word has persisted). Large but read-only — use this to discover what setting paths exist before set_config.

### `set_config` (~110 tokens)

Patch the config store. Pass EITHER {path, value} for a single dotted-path write (e.g. path="engine.model", value="small"), OR {patch: {...}} for a flat object of dotted-path → value pairs applied in order. Changes persist immediately.

Input parameters:

- `patch` (object): Object of dotted-path → value, applied in iteration order.
- `path` (string): Dotted path (e.g. "engine.model").
- `value`: Value for the single-path form.

### `toggle_recording` (~52 tokens)

Toggle voice recording on or off (same effect as the global hotkey). If currently idle, starts listening. If currently recording, stops and triggers the transcription + paste pipeline against whatever window had focus when recording started.

### `paste_transcript` (~38 tokens)

Re-paste the most recent transcript into the focused window (same effect as the paste-transcript hotkey). Does NOT start a new recording.

### `show_hide_window` (~29 tokens)

Cycle the Windy Word window through its three states: full → mini tornado → hidden → full.

### `quick_translate` (~15 tokens)

Open the Quick Translate mini-window.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/sneakyfree-windy-word-mcp/windy-word-mcp#diagnostics

## Score history

- 2026-08-03: 69
- 2026-08-02: 69
- 2026-08-01: 26
- 2026-07-31: 21
- 2026-07-30: 28
- 2026-07-28: 46
- 2026-07-27: 46

## Links

- npm package: https://www.npmjs.com/package/windy-word-mcp
- Socket report: https://socket.dev/npm/package/windy-word-mcp
- Repository: https://github.com/sneakyfree/windy-word-mcp
- Website: https://windyword.ai/
- Changelog RSS feed: https://verifymcp.io/servers/sneakyfree-windy-word-mcp/windy-word-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/sneakyfree-windy-word-mcp/windy-word-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/sneakyfree-windy-word-mcp/windy-word-mcp