From 5819f32d139a4cfc172b03a8e647af1445f7223b Mon Sep 17 00:00:00 2001
From: Ray Zhang <m@raycursive.com>
Date: Fri, 14 Aug 2026 22:13:53 -0400
Subject: [PATCH] add plugin Discord Voice

---
 discord-voice/README.md            |   73 ++
 discord-voice/bar.luau             |  143 +++
 discord-voice/discord_bridge.py    | 1411 ++++++++++++++++++++++++++++
 discord-voice/panel.luau           |  614 ++++++++++++
 discord-voice/plugin.toml          |   54 ++
 discord-voice/service.luau         |  118 +++
 discord-voice/thumbnail.webp       |  Bin 0 -> 40540 bytes
 discord-voice/translations/en.json |   79 ++
 8 files changed, 2492 insertions(+)
 create mode 100644 discord-voice/README.md
 create mode 100644 discord-voice/bar.luau
 create mode 100644 discord-voice/discord_bridge.py
 create mode 100644 discord-voice/panel.luau
 create mode 100644 discord-voice/plugin.toml
 create mode 100644 discord-voice/service.luau
 create mode 100644 discord-voice/thumbnail.webp
 create mode 100644 discord-voice/translations/en.json

diff --git a/discord-voice/README.md b/discord-voice/README.md
new file mode 100644
index 00000000..e6e52618
--- /dev/null
+++ b/discord-voice/README.md
@@ -0,0 +1,73 @@
+# Discord Voice
+
+Monitor and control a local Discord desktop voice session without leaving Noctalia. The bar widget and panel expose voice state and controls through Discord's local RPC interface.
+
+## Plugin
+
+| Field | Value |
+| --- | --- |
+| ID | `raycursive/discord-voice` |
+| Entries | Bar widget: `bar`; panel: `panel`; service: `bridge` |
+
+## Requirements
+
+- Noctalia with plugin API 9 or newer.
+- `python3` 3.10 or newer on `PATH` for the local Discord RPC bridge.
+- The `discord` desktop client. The default executable is `/usr/bin/discord`; change **Discord executable** if yours is elsewhere.
+
+Discord must be running locally. The bridge detects native, Flatpak, Snap, and common temporary Discord IPC socket locations; the Discord web app alone is not sufficient.
+
+## Usage
+
+Enable `raycursive/discord-voice` in **Settings → Plugins**, then add the `bar` entry from **Settings → Bar → Widgets**.
+
+1. Click the bar widget to open the `panel` entry. If Discord is not running, the first click launches the configured Discord executable.
+2. Select **Authorize Discord** and accept Discord's local consent prompt.
+3. Use the panel to mute, deafen, hang up, adjust your input volume from 0–100%, or adjust another participant's listening volume from 0–200%.
+4. Select saved recent or favorite channels to rejoin them in Discord.
+
+The `bridge` service starts automatically when the plugin is enabled and keeps the bar widget and panel synchronized. Open the panel without the bar widget with:
+
+```sh
+noctalia msg panel-toggle raycursive/discord-voice:panel
+```
+
+## Settings
+
+| Setting | Type | Default | Description |
+| --- | --- | --- | --- |
+| `discord_binary` | `file` | `/usr/bin/discord` | Executable used to launch Discord and open channel deep links. |
+| `glyph` | `glyph` | `brand-discord` | Glyph used by this bar-widget instance when no participant avatar is shown. |
+| `show_channel_name` | `bool` | `true` | Shows the active voice-channel name beside the glyph. |
+| `hide_when_disconnected` | `bool` | `false` | Hides the bar widget while no voice channel is connected. |
+
+## IPC
+
+The `bridge` service accepts these events:
+
+```sh
+# Start Discord's local authorization flow.
+noctalia msg plugin raycursive/discord-voice:bridge all authorize
+
+# Refresh current voice and channel state.
+noctalia msg plugin raycursive/discord-voice:bridge all refresh
+
+# Leave the current voice channel.
+noctalia msg plugin raycursive/discord-voice:bridge all hangup
+
+# Write a token-free state summary to the Noctalia log.
+noctalia msg plugin raycursive/discord-voice:bridge all dump
+```
+
+## Notes
+
+- The plugin requests only the Discord OAuth scopes `rpc`, `rpc.voice.read`, and `rpc.voice.write`. It does not request message, notification, relationship, or guild-member scopes.
+- Authorization sends the code to `https://streamkit.discord.com/overlay/token`. Participant avatars are downloaded from `https://cdn.discordapp.com`; no downloaded content is executed.
+- The Python bridge connects to Discord and to its own control channel over local Unix sockets. Noctalia spawns the bridge, and the bar or panel may spawn the configured Discord executable.
+- The access token is stored at `$NOCTALIA_STATE_HOME/noctalia/discord-voice/token.json`, or under `$XDG_STATE_HOME` when the Noctalia override is unset. Recent and favorite channel metadata is stored beside it in `channels.json`. The directory uses mode `0700` and both files use mode `0600`.
+- Participant avatars are cached under `$XDG_CACHE_HOME/noctalia/discord-voice/avatars/`. The bridge's control socket is created under `$XDG_RUNTIME_DIR`, with a per-user `/tmp` fallback, and removed on a clean shutdown.
+- Discord's StreamKit token exchange does not provide a refresh token. Authorize again after the access token expires.
+- Voice levels changed through Discord RPC belong to the active integration; Discord may restore previous levels when the bridge disconnects.
+- The bridge reconnects after Discord restarts. The integration depends on Discord's public StreamKit identity and token broker, which Discord may change.
+
+The authorization design was from [`PandorasFox/dms-discord-widget`](https://github.com/PandorasFox/dms-discord-widget).
diff --git a/discord-voice/bar.luau b/discord-voice/bar.luau
new file mode 100644
index 00000000..0d88c14d
--- /dev/null
+++ b/discord-voice/bar.luau
@@ -0,0 +1,143 @@
+--!nonstrict
+
+local PANEL_ID = "raycursive/discord-voice:panel"
+local snapshot = noctalia.state.get("voice_snapshot") or {
+  status = "starting",
+  status_message = "",
+  channel = nil,
+  recent_channels = {},
+  favorite_channels = {},
+  participants = {},
+  voice = { mute = false, deaf = false, input_volume = 100 },
+  connection = { state = "DISCONNECTED", average_ping = 0 },
+  connected_since = nil,
+}
+
+local tr = noctalia.tr
+
+local function shortened(text, limit)
+  local length = utf8.len(text)
+  if length <= limit then
+    return text
+  end
+  local cut = utf8.offset(text, limit + 1)
+  return text:sub(1, cut - 1) .. "…"
+end
+
+local function activeSpeaker()
+  for _, participant in ipairs(snapshot.participants) do
+    if participant.speaking then
+      return participant
+    end
+  end
+  return nil
+end
+
+local function statusLabel()
+  if snapshot.status == "auth_required" then
+    return tr("bar.authorize")
+  elseif snapshot.status == "authorizing" or snapshot.status == "authenticating" then
+    return tr("bar.authorizing")
+  elseif snapshot.status == "discord_unavailable" then
+    return tr("bar.offline")
+  elseif snapshot.status == "error" then
+    return "!"
+  end
+  return ""
+end
+
+local function render()
+  local disconnected = snapshot.channel == nil
+  if disconnected and noctalia.getConfig("hide_when_disconnected") == true then
+    barWidget.setVisible(false)
+    return
+  end
+  barWidget.setVisible(true)
+
+  local glyph = noctalia.getConfig("glyph")
+  if type(glyph) ~= "string" or glyph == "" then
+    glyph = "brand-discord"
+  end
+
+  local children = {}
+  local voice = snapshot.voice
+  local speaker = activeSpeaker()
+  local glyphColor = "on_surface_variant"
+  if speaker ~= nil then
+    glyphColor = "primary"
+  elseif not disconnected then
+    glyphColor = (voice.mute or voice.deaf) and "error" or "primary"
+  elseif snapshot.status == "error" then
+    glyphColor = "error"
+  end
+  if speaker and speaker.avatar_path ~= "" then
+    table.insert(children, ui.image({
+      key = "speaker:" .. speaker.id,
+      path = speaker.avatar_path,
+      width = 20,
+      height = 20,
+      radius = 10,
+      fit = "cover",
+      border = "primary",
+      borderWidth = 2,
+    }))
+  elseif speaker then
+    table.insert(children, ui.glyph({ name = "volume", size = 16, color = glyphColor }))
+  else
+    table.insert(children, ui.glyph({ name = glyph, size = 15, color = glyphColor }))
+  end
+
+  if disconnected then
+    local label = statusLabel()
+    if label ~= "" then
+      table.insert(children, ui.label({ text = label, color = "on_surface_variant", fontSize = 12 }))
+    end
+  else
+    if noctalia.getConfig("show_channel_name") ~= false then
+      table.insert(children, ui.label({
+        text = shortened(snapshot.channel.name, 18),
+        color = "on_surface",
+        fontWeight = "bold",
+      }))
+    end
+    table.insert(children, ui.label({
+      text = tostring(#snapshot.participants),
+      color = "on_surface_variant",
+      fontSize = 12,
+    }))
+  end
+
+  local container = barWidget.isVertical() and ui.column or ui.row
+  barWidget.render(container({ gap = 6, align = "center", paddingH = 4, paddingV = 2 }, children))
+  barWidget.setTooltip({})
+end
+
+noctalia.state.watch("voice_snapshot", function(value)
+  if type(value) == "table" then
+    snapshot = value
+    render()
+  end
+end)
+
+noctalia.setUpdateInterval(1000)
+render()
+
+function update()
+  render()
+end
+
+function onClick()
+  if snapshot.status == "discord_unavailable" then
+    local binary = noctalia.getConfig("discord_binary")
+    if type(binary) ~= "string" or binary == "" then
+      binary = "/usr/bin/discord"
+    end
+    noctalia.runAsync("'" .. binary:gsub("'", "'\\''") .. "'")
+    return
+  end
+  noctalia.togglePanel(PANEL_ID)
+end
+
+function onConfigChanged()
+  render()
+end
diff --git a/discord-voice/discord_bridge.py b/discord-voice/discord_bridge.py
new file mode 100644
index 00000000..5a8c294b
--- /dev/null
+++ b/discord-voice/discord_bridge.py
@@ -0,0 +1,1411 @@
+#!/usr/bin/env python3
+"""Discord desktop RPC bridge for the Noctalia Discord Voice plugin.
+
+The daemon connects to Discord's local IPC socket and writes state snapshots as
+JSON lines to stdout. Short-lived ``command`` invocations talk to the daemon's
+private control socket, which lets Noctalia buttons control the persistent RPC
+session without exposing the OAuth token to Luau or process arguments.
+
+Python 3.10+ standard library only.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import math
+import os
+import signal
+import socket
+import struct
+import sys
+import tempfile
+import time
+import urllib.request
+from pathlib import Path
+from typing import Any, TypedDict
+
+
+STREAMKIT_CLIENT_ID = "207646673902501888"
+OAUTH_SCOPES = ("rpc", "rpc.voice.read", "rpc.voice.write")
+TOKEN_EXCHANGE_URL = "https://streamkit.discord.com/overlay/token"
+HTTP_USER_AGENT = "Noctalia-Discord-Voice"
+
+OP_HANDSHAKE = 0
+OP_FRAME = 1
+OP_CLOSE = 2
+OP_PING = 3
+OP_PONG = 4
+
+RECONNECT_SECONDS = 3
+HEARTBEAT_SECONDS = 5
+MAX_AVATAR_BYTES = 2 * 1024 * 1024
+MAX_RPC_PAYLOAD_BYTES = 8 * 1024 * 1024
+MAX_RECENT_CHANNELS = 5
+MAX_FAVORITE_CHANNELS = 5
+VOICE_STATE_EVENTS = (
+    "VOICE_STATE_CREATE",
+    "VOICE_STATE_UPDATE",
+    "VOICE_STATE_DELETE",
+)
+SPEAKING_EVENTS = ("SPEAKING_START", "SPEAKING_STOP")
+
+
+class VoiceSettings(TypedDict):
+    mute: bool
+    deaf: bool
+    input_volume: int
+
+
+def normalized_volume(value: Any, default: int, maximum: int) -> int:
+    """Return a finite Discord volume value clamped to its documented range."""
+
+    try:
+        number = float(value)
+    except (TypeError, ValueError, OverflowError):
+        return default
+    if not math.isfinite(number):
+        return default
+    return max(0, min(maximum, int(round(number))))
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="[noctalia-discord-voice] %(levelname)s: %(message)s",
+    stream=sys.stderr,
+)
+log = logging.getLogger("discord-voice")
+
+
+def _xdg_dir(name: str, fallback: str) -> Path:
+    value = os.environ.get(name)
+    return Path(value).expanduser() if value else Path(fallback).expanduser()
+
+
+def control_socket_path() -> Path:
+    runtime = os.environ.get("XDG_RUNTIME_DIR")
+    if runtime:
+        return Path(runtime) / "noctalia-discord-voice.sock"
+    return Path("/tmp") / f"noctalia-discord-voice-{os.getuid()}.sock"
+
+
+def state_directory() -> Path:
+    root = os.environ.get("NOCTALIA_STATE_HOME")
+    base = (
+        Path(root).expanduser()
+        if root
+        else _xdg_dir("XDG_STATE_HOME", "~/.local/state")
+    )
+    return base / "noctalia" / "discord-voice"
+
+
+def avatar_directory() -> Path:
+    return (
+        _xdg_dir("XDG_CACHE_HOME", "~/.cache")
+        / "noctalia"
+        / "discord-voice"
+        / "avatars"
+    )
+
+
+def write_private_json(path: Path, payload: dict[str, Any]) -> None:
+    """Atomically write JSON with private directory and file permissions."""
+
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    try:
+        os.chmod(path.parent, 0o700)
+    except OSError:
+        pass
+
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.", suffix=".tmp", dir=path.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle)
+        os.replace(temporary, path)
+        os.chmod(path, 0o600)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+class TokenStore:
+    """Small 0600 token store. Tokens are never included in bridge output."""
+
+    def __init__(self) -> None:
+        self.path = state_directory() / "token.json"
+
+    def load(self) -> str | None:
+        try:
+            payload = json.loads(self.path.read_text(encoding="utf-8"))
+            token = payload.get("access_token")
+            return token if isinstance(token, str) and token else None
+        except (FileNotFoundError, json.JSONDecodeError, OSError):
+            return None
+
+    def save(self, token: str) -> None:
+        write_private_json(self.path, {"access_token": token})
+
+    def clear(self) -> None:
+        try:
+            self.path.unlink()
+        except FileNotFoundError:
+            pass
+        except OSError as error:
+            log.warning("Could not remove expired Discord token: %s", error)
+
+
+class ChannelStore:
+    """Private local history for recent and favorite voice channels."""
+
+    def __init__(self) -> None:
+        self.path = state_directory() / "channels.json"
+
+    @staticmethod
+    def _channel(value: Any) -> dict[str, Any] | None:
+        if not isinstance(value, dict) or not value.get("id"):
+            return None
+        try:
+            last_joined_time = int(value.get("last_joined_time") or 0)
+        except (TypeError, ValueError, OverflowError):
+            last_joined_time = 0
+        return {
+            "id": str(value.get("id")),
+            "name": str(value.get("name") or "Voice channel"),
+            "guild_id": str(value.get("guild_id") or ""),
+            "guild_name": str(value.get("guild_name") or ""),
+            "last_joined_time": last_joined_time,
+        }
+
+    @classmethod
+    def _channels(cls, value: Any, limit: int) -> list[dict[str, Any]]:
+        # Version 0.1 stored a single object at ``recent``. Accept it so users
+        # keep their saved channel when upgrading to the five-item history.
+        values = value if isinstance(value, list) else [value]
+        channels: list[dict[str, Any]] = []
+        seen: set[str] = set()
+        for item in values:
+            channel = cls._channel(item)
+            if channel and channel["id"] not in seen:
+                channels.append(channel)
+                seen.add(channel["id"])
+            if len(channels) == limit:
+                break
+        return channels
+
+    def load(self) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        try:
+            payload = json.loads(self.path.read_text(encoding="utf-8"))
+        except (FileNotFoundError, json.JSONDecodeError, OSError):
+            return [], []
+        if not isinstance(payload, dict):
+            return [], []
+        favorites = payload.get("favorites")
+        if not isinstance(favorites, list):
+            # Migrate the original single pinned channel in place.
+            favorites = [payload.get("pinned")]
+        recent_channels = self._channels(payload.get("recent"), MAX_RECENT_CHANNELS)
+        favorite_channels = self._channels(favorites, MAX_FAVORITE_CHANNELS)
+
+        # Older state has recency encoded only by array position. Backfill a
+        # stable timestamp rank so favorites shared with the recent list keep
+        # the same last-joined ordering after the new activity sort is applied.
+        known_times = [
+            channel["last_joined_time"]
+            for channel in (*recent_channels, *favorite_channels)
+        ]
+        try:
+            state_mtime = int(self.path.stat().st_mtime)
+        except OSError:
+            state_mtime = 0
+        migration_base = max(state_mtime, *known_times)
+        migrated = False
+        recent_times: dict[str, int] = {}
+        for index, channel in enumerate(recent_channels):
+            if channel["last_joined_time"] <= 0:
+                channel["last_joined_time"] = migration_base - index
+                migrated = True
+            recent_times[channel["id"]] = channel["last_joined_time"]
+        for index, channel in enumerate(favorite_channels):
+            recent_time = recent_times.get(channel["id"])
+            if (
+                recent_time is not None
+                and channel["last_joined_time"] != recent_time
+            ):
+                channel["last_joined_time"] = recent_time
+                migrated = True
+            elif channel["last_joined_time"] <= 0:
+                channel["last_joined_time"] = (
+                    migration_base - len(recent_channels) - index
+                )
+                migrated = True
+
+        if migrated:
+            self.save(recent_channels, favorite_channels)
+        return recent_channels, favorite_channels
+
+    def save(
+        self, recent: list[dict[str, Any]], favorites: list[dict[str, Any]]
+    ) -> None:
+        payload = {
+            "recent": self._channels(recent, MAX_RECENT_CHANNELS),
+            "favorites": self._channels(favorites, MAX_FAVORITE_CHANNELS),
+        }
+        write_private_json(self.path, payload)
+
+
+class DiscordIPC:
+    """Binary-framed connection to Discord's documented local RPC server."""
+
+    def __init__(self) -> None:
+        self.reader: asyncio.StreamReader | None = None
+        self.writer: asyncio.StreamWriter | None = None
+        self._write_lock = asyncio.Lock()
+
+    @staticmethod
+    def candidate_paths() -> list[Path]:
+        directories: list[Path] = []
+        runtime = os.environ.get("XDG_RUNTIME_DIR")
+        if runtime:
+            runtime_path = Path(runtime)
+            directories.append(runtime_path)
+            directories.append(runtime_path / "app" / "com.discordapp.Discord")
+
+        snap_data = os.environ.get("SNAP_USER_DATA")
+        if snap_data:
+            directories.append(Path(snap_data) / ".config")
+
+        for variable in ("TMPDIR", "TMP", "TEMP"):
+            value = os.environ.get(variable)
+            if value:
+                directories.append(Path(value))
+        directories.append(Path("/tmp"))
+
+        paths: list[Path] = []
+        seen: set[Path] = set()
+        for directory in directories:
+            for index in range(10):
+                path = directory / f"discord-ipc-{index}"
+                if path not in seen:
+                    seen.add(path)
+                    paths.append(path)
+        return paths
+
+    @property
+    def connected(self) -> bool:
+        return self.writer is not None and not self.writer.is_closing()
+
+    async def connect(self) -> Path | None:
+        for path in self.candidate_paths():
+            if not path.exists():
+                continue
+            try:
+                self.reader, self.writer = await asyncio.open_unix_connection(path)
+                return path
+            except OSError:
+                continue
+        return None
+
+    async def send(self, opcode: int, payload: dict[str, Any]) -> None:
+        if not self.writer:
+            raise ConnectionError("Discord IPC is not connected")
+        encoded = json.dumps(payload, separators=(",", ":")).encode("utf-8")
+        frame = struct.pack("<II", opcode, len(encoded)) + encoded
+        async with self._write_lock:
+            self.writer.write(frame)
+            await self.writer.drain()
+
+    async def receive(self) -> tuple[int, dict[str, Any]]:
+        if not self.reader:
+            raise ConnectionError("Discord IPC is not connected")
+        header = await self.reader.readexactly(8)
+        opcode, length = struct.unpack("<II", header)
+        if length > MAX_RPC_PAYLOAD_BYTES:
+            raise ValueError(f"Discord RPC payload is too large: {length} bytes")
+        encoded = await self.reader.readexactly(length)
+        payload = json.loads(encoded.decode("utf-8"))
+        if not isinstance(payload, dict):
+            raise ValueError("Discord returned a non-object payload")
+        return opcode, payload
+
+    async def handshake(self) -> dict[str, Any]:
+        await self.send(OP_HANDSHAKE, {"v": 1, "client_id": STREAMKIT_CLIENT_ID})
+        opcode, payload = await self.receive()
+        if opcode == OP_CLOSE:
+            raise ConnectionError("Discord rejected the StreamKit handshake")
+        if payload.get("evt") != "READY":
+            raise ConnectionError("Discord did not return READY")
+        return payload
+
+    async def close(self) -> None:
+        writer = self.writer
+        self.reader = None
+        self.writer = None
+        if writer:
+            writer.close()
+            try:
+                await writer.wait_closed()
+            except OSError:
+                pass
+
+
+def exchange_authorization_code(code: str) -> str:
+    body = json.dumps({"code": code}).encode("utf-8")
+    request = urllib.request.Request(
+        TOKEN_EXCHANGE_URL,
+        data=body,
+        headers={
+            "Content-Type": "application/json",
+            "User-Agent": HTTP_USER_AGENT,
+        },
+        method="POST",
+    )
+    with urllib.request.urlopen(request, timeout=15) as response:
+        payload = json.loads(response.read().decode("utf-8"))
+    token = payload.get("access_token")
+    if not isinstance(token, str) or not token:
+        raise ValueError("StreamKit returned no access token")
+    return token
+
+
+def download_avatar(user_id: str, avatar_hash: str, destination: Path) -> Path:
+    destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    try:
+        os.chmod(destination.parent, 0o700)
+    except OSError:
+        pass
+    url = f"https://cdn.discordapp.com/avatars/{user_id}/{avatar_hash}.png?size=64"
+    request = urllib.request.Request(url, headers={"User-Agent": HTTP_USER_AGENT})
+    with urllib.request.urlopen(request, timeout=10) as response:
+        content = response.read(MAX_AVATAR_BYTES + 1)
+    if len(content) > MAX_AVATAR_BYTES:
+        raise ValueError("Discord avatar exceeded the size limit")
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{destination.name}.", suffix=".tmp", dir=destination.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as handle:
+            handle.write(content)
+        os.replace(temporary, destination)
+    finally:
+        temporary.unlink(missing_ok=True)
+    return destination
+
+
+class DiscordVoiceBridge:
+    def __init__(self) -> None:
+        self.ipc = DiscordIPC()
+        self.tokens = TokenStore()
+        self.channels = ChannelStore()
+        self.control_path = control_socket_path()
+        self.control_server: asyncio.AbstractServer | None = None
+        self.stop_event = asyncio.Event()
+
+        self.status = "starting"
+        self.status_message = ""
+        self.authenticated = False
+        self.current_user: dict[str, Any] = {}
+        self.channel: dict[str, Any] | None = None
+        self.recent_channels, self.favorite_channels = self.channels.load()
+        self.participants: dict[str, dict[str, Any]] = {}
+        self.voice_settings: VoiceSettings = {
+            "mute": False,
+            "deaf": False,
+            "input_volume": 100,
+        }
+        self.connection: dict[str, Any] = {
+            "state": "DISCONNECTED",
+            "hostname": "",
+            "average_ping": 0,
+            "last_ping": 0,
+        }
+        self.connected_since: int | None = None
+        self.revision = 0
+        self.pending: dict[str, dict[str, Any]] = {}
+        self.next_nonce = 0
+        self.active_token: str | None = None
+        self.avatar_tasks: dict[str, asyncio.Task[None]] = {}
+        self.saved_channel_counts: dict[str, int] = {}
+        self.channel_event_subscriptions: dict[str, set[str]] = {}
+
+    async def run(self) -> None:
+        loop = asyncio.get_running_loop()
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            try:
+                loop.add_signal_handler(sig, self.stop_event.set)
+            except NotImplementedError:
+                pass
+
+        await self._start_control_server()
+        supervisor = asyncio.create_task(self._supervise_discord())
+        heartbeat = asyncio.create_task(self._heartbeat())
+        self._emit_snapshot()
+
+        await self.stop_event.wait()
+        supervisor.cancel()
+        heartbeat.cancel()
+        await asyncio.gather(supervisor, heartbeat, return_exceptions=True)
+        for task in self.avatar_tasks.values():
+            task.cancel()
+        await asyncio.gather(*self.avatar_tasks.values(), return_exceptions=True)
+        await self.ipc.close()
+        if self.control_server:
+            self.control_server.close()
+            await self.control_server.wait_closed()
+        try:
+            self.control_path.unlink()
+        except FileNotFoundError:
+            pass
+
+    def _write_event(self, payload: dict[str, Any]) -> None:
+        try:
+            sys.stdout.write(json.dumps(payload, separators=(",", ":")) + "\n")
+            sys.stdout.flush()
+        except (BrokenPipeError, OSError):
+            self.stop_event.set()
+
+    def _emit_snapshot(self) -> None:
+        self.revision += 1
+        participants: list[dict[str, Any]] = []
+        for participant in self.participants.values():
+            participants.append(
+                {
+                    key: value
+                    for key, value in participant.items()
+                    if key != "avatar_hash"
+                }
+            )
+        participants.sort(
+            key=lambda item: (
+                item["nick"].casefold(),
+                item["id"],
+            )
+        )
+
+        self._write_event(
+            {
+                "type": "snapshot",
+                "revision": self.revision,
+                "status": self.status,
+                "status_message": self.status_message,
+                "authenticated": self.authenticated,
+                "user": self.current_user,
+                "channel": self.channel,
+                "recent_channels": self._sorted_saved_channels(self.recent_channels),
+                "favorite_channels": self._sorted_saved_channels(
+                    self.favorite_channels
+                ),
+                "participants": participants,
+                "voice": self.voice_settings,
+                "connection": self.connection,
+                "connected_since": self.connected_since,
+            }
+        )
+
+    def _sorted_saved_channels(
+        self, channels: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        decorated: list[dict[str, Any]] = []
+        for channel in channels:
+            entry = dict(channel)
+            entry["participant_count"] = max(
+                0, self.saved_channel_counts.get(channel["id"], 0)
+            )
+            decorated.append(entry)
+        return sorted(
+            decorated,
+            key=lambda entry: (
+                entry["participant_count"] > 0,
+                entry["last_joined_time"],
+            ),
+            reverse=True,
+        )
+
+    def _set_status(self, status: str, message: str = "") -> None:
+        changed = status != self.status or message != self.status_message
+        self.status = status
+        self.status_message = message
+        if changed:
+            self._emit_snapshot()
+
+    async def _heartbeat(self) -> None:
+        while not self.stop_event.is_set():
+            await asyncio.sleep(HEARTBEAT_SECONDS)
+            self._write_event({"type": "heartbeat", "time": int(time.time())})
+
+    async def _start_control_server(self) -> None:
+        self.control_path.parent.mkdir(parents=True, exist_ok=True)
+        for attempt in range(51):
+            if not self.control_path.exists():
+                break
+            probe = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            probe.settimeout(0.1)
+            occupied = False
+            try:
+                probe.connect(str(self.control_path))
+                occupied = True
+            except OSError:
+                self.control_path.unlink(missing_ok=True)
+                break
+            finally:
+                probe.close()
+            if occupied and attempt < 50:
+                # Noctalia can start a replacement service just before the old
+                # runStream process has finished cleaning up during hot reload.
+                await asyncio.sleep(0.1)
+                continue
+            raise RuntimeError(f"another bridge owns {self.control_path}")
+
+        self.control_server = await asyncio.start_unix_server(
+            self._handle_control_client, path=str(self.control_path)
+        )
+        os.chmod(self.control_path, 0o600)
+        log.info("Control socket ready at %s", self.control_path)
+
+    async def _handle_control_client(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        response: dict[str, Any]
+        try:
+            encoded = await asyncio.wait_for(reader.readline(), timeout=3)
+            request = json.loads(encoded.decode("utf-8"))
+            response = await self._handle_control_command(request)
+        except Exception as error:
+            response = {"ok": False, "error": str(error)}
+
+        writer.write(
+            json.dumps(response, separators=(",", ":")).encode("utf-8") + b"\n"
+        )
+        try:
+            await writer.drain()
+        finally:
+            writer.close()
+            try:
+                await writer.wait_closed()
+            except OSError:
+                pass
+
+    def _saved_channel(self, channel_id: str) -> dict[str, Any] | None:
+        return next(
+            (
+                channel
+                for channel in (*self.favorite_channels, *self.recent_channels)
+                if channel["id"] == channel_id
+            ),
+            None,
+        )
+
+    async def _save_channel_lists(self) -> None:
+        self.channels.save(self.recent_channels, self.favorite_channels)
+        await self._sync_channel_subscriptions()
+        self._emit_snapshot()
+
+    async def _favorite_channel(self, channel_id: str) -> dict[str, Any]:
+        channel = (
+            self.channel
+            if self.channel and self.channel["id"] == channel_id
+            else self._saved_channel(channel_id)
+        )
+        if channel is None:
+            return {"ok": False, "error": "Channel is no longer available"}
+
+        self.favorite_channels = [
+            dict(channel),
+            *[
+                favorite
+                for favorite in self.favorite_channels
+                if favorite["id"] != channel_id
+            ],
+        ][:MAX_FAVORITE_CHANNELS]
+        await self._save_channel_lists()
+        return {"ok": True}
+
+    async def _unfavorite_channel(self, channel_id: str) -> dict[str, Any]:
+        remaining = [
+            channel for channel in self.favorite_channels if channel["id"] != channel_id
+        ]
+        if len(remaining) == len(self.favorite_channels):
+            return {"ok": False, "error": "Favorite channel is no longer available"}
+        self.favorite_channels = remaining
+        await self._save_channel_lists()
+        return {"ok": True}
+
+    async def _join_channel(self, channel_id: str) -> dict[str, Any]:
+        if self._saved_channel(channel_id) is None:
+            return {"ok": False, "error": "Saved channel is no longer available"}
+        await self._request(
+            "SELECT_VOICE_CHANNEL",
+            {"channel_id": channel_id},
+            kind="join_channel",
+        )
+        return {"ok": True}
+
+    async def _handle_control_command(self, request: dict[str, Any]) -> dict[str, Any]:
+        command = request["command"]
+        if command == "status":
+            sorted_favorites = self._sorted_saved_channels(self.favorite_channels)
+            sorted_recents = self._sorted_saved_channels(self.recent_channels)
+            return {
+                "ok": True,
+                "status": self.status,
+                "authenticated": self.authenticated,
+                "in_voice": self.channel is not None,
+                "channel": self.channel["name"] if self.channel else "",
+                "participant_count": len(self.participants),
+                "speaking_count": sum(
+                    1
+                    for participant in self.participants.values()
+                    if participant["speaking"]
+                ),
+                "connection_state": self.connection["state"],
+                "average_ping": self.connection["average_ping"],
+                "saved_channel": (sorted_favorites[0] if sorted_favorites else None)
+                or (sorted_recents[0] if sorted_recents else None),
+            }
+        if command == "authorize":
+            await self._begin_authorization()
+            return {"ok": True}
+        if command == "refresh":
+            self.status_message = ""
+            if self.authenticated:
+                await self._request(
+                    "GET_SELECTED_VOICE_CHANNEL", kind="selected_channel"
+                )
+                await self._request("GET_VOICE_SETTINGS", kind="voice_settings")
+                await self._refresh_saved_channel_counts()
+            return {"ok": True}
+        if not self.authenticated:
+            return {"ok": False, "error": "Authorize Discord first"}
+        if command in ("favorite_channel", "unfavorite_channel", "join_channel"):
+            channel_id = request["value"]
+            if command == "favorite_channel":
+                return await self._favorite_channel(channel_id)
+            if command == "unfavorite_channel":
+                return await self._unfavorite_channel(channel_id)
+            return await self._join_channel(channel_id)
+        if command == "set_mute":
+            await self._request(
+                "SET_VOICE_SETTINGS",
+                {"mute": request["value"]},
+                kind="voice_settings",
+            )
+            return {"ok": True}
+        if command == "set_deaf":
+            await self._request(
+                "SET_VOICE_SETTINGS",
+                {"deaf": request["value"]},
+                kind="voice_settings",
+            )
+            return {"ok": True}
+        if command == "set_mic_volume":
+            volume = request["value"]
+            previous_volume = self.voice_settings["input_volume"]
+            self.voice_settings["input_volume"] = volume
+            self.status_message = ""
+            self._emit_snapshot()
+            await self._request(
+                "SET_VOICE_SETTINGS",
+                {"input": {"volume": volume}},
+                kind="mic_volume",
+                meta={
+                    "previous_volume": previous_volume,
+                    "target_volume": volume,
+                },
+            )
+            return {"ok": True}
+        if command == "set_user_volume":
+            user_id = request["user_id"]
+            if not self.channel or user_id not in self.participants:
+                return {
+                    "ok": False,
+                    "error": "Participant is no longer in this channel",
+                }
+            if user_id == self.current_user["id"]:
+                return {
+                    "ok": False,
+                    "error": "Use microphone volume to change your own input level",
+                }
+            volume = request["value"]
+            participant = self.participants[user_id]
+            previous_volume = participant["volume"]
+            participant["volume"] = volume
+            self.status_message = ""
+            self._emit_snapshot()
+            await self._request(
+                "SET_USER_VOICE_SETTINGS",
+                {"user_id": user_id, "volume": volume},
+                kind="user_voice_settings",
+                meta={
+                    "user_id": user_id,
+                    "previous_volume": previous_volume,
+                    "target_volume": volume,
+                },
+            )
+            return {"ok": True}
+        if command == "hang_up":
+            await self._request(
+                "SELECT_VOICE_CHANNEL",
+                {"channel_id": None},
+                kind="hang_up",
+            )
+            return {"ok": True}
+        return {"ok": False, "error": f"unknown command: {command}"}
+
+    async def _supervise_discord(self) -> None:
+        while not self.stop_event.is_set():
+            try:
+                await self._discord_session()
+            except asyncio.CancelledError:
+                raise
+            except Exception as error:
+                log.warning("Discord session ended: %s", error)
+                self._set_status("discord_unavailable", str(error))
+            finally:
+                await self.ipc.close()
+                self._reset_session_state()
+
+            if not self.stop_event.is_set():
+                await asyncio.sleep(RECONNECT_SECONDS)
+
+    async def _discord_session(self) -> None:
+        self._set_status("connecting")
+        path = await self.ipc.connect()
+        if not path:
+            raise ConnectionError("Discord desktop is not running")
+        await self.ipc.handshake()
+        log.info("Connected to Discord IPC at %s", path)
+
+        token = self.tokens.load()
+        if token:
+            self.active_token = token
+            self._set_status("authenticating")
+            await self._request(
+                "AUTHENTICATE", {"access_token": token}, kind="authenticate"
+            )
+        else:
+            self._set_status("auth_required")
+
+        while not self.stop_event.is_set():
+            opcode, payload = await self.ipc.receive()
+            if opcode == OP_CLOSE:
+                raise ConnectionError("Discord closed the RPC connection")
+            if opcode == OP_PING:
+                await self.ipc.send(OP_PONG, payload)
+                continue
+            if opcode == OP_PONG:
+                continue
+            await self._handle_discord_payload(payload)
+
+    def _reset_session_state(self) -> None:
+        self.pending.clear()
+        self.channel_event_subscriptions.clear()
+        self.saved_channel_counts.clear()
+        self.authenticated = False
+        self.current_user = {}
+        self.channel = None
+        self.participants.clear()
+        self.voice_settings = {"mute": False, "deaf": False, "input_volume": 100}
+        self.connection = {
+            "state": "DISCONNECTED",
+            "hostname": "",
+            "average_ping": 0,
+            "last_ping": 0,
+        }
+        self.connected_since = None
+        if self.status not in ("discord_unavailable", "connecting"):
+            self.status = "discord_unavailable"
+        self._emit_snapshot()
+
+    async def _request(
+        self,
+        command: str,
+        args: dict[str, Any] | None = None,
+        *,
+        kind: str,
+        meta: dict[str, Any] | None = None,
+        event: str | None = None,
+    ) -> str:
+        if not self.ipc.connected:
+            raise ConnectionError("Discord IPC is not connected")
+        self.next_nonce += 1
+        nonce = str(self.next_nonce)
+        payload: dict[str, Any] = {"cmd": command, "nonce": nonce}
+        if args is not None:
+            payload["args"] = args
+        if event is not None:
+            payload["evt"] = event
+        self.pending[nonce] = {"kind": kind, "meta": meta or {}}
+        await self.ipc.send(OP_FRAME, payload)
+        return nonce
+
+    async def _subscribe(
+        self,
+        event: str,
+        args: dict[str, Any] | None = None,
+        *,
+        meta: dict[str, Any] | None = None,
+    ) -> None:
+        await self._request("SUBSCRIBE", args, kind="subscribe", meta=meta, event=event)
+
+    async def _unsubscribe(self, event: str, args: dict[str, Any]) -> None:
+        try:
+            await self._request("UNSUBSCRIBE", args, kind="unsubscribe", event=event)
+        except ConnectionError:
+            pass
+
+    async def _begin_authorization(self) -> None:
+        if not self.ipc.connected:
+            raise ConnectionError("Start Discord desktop before authorizing")
+        if any(item["kind"] == "authorize" for item in self.pending.values()):
+            return
+        self._set_status("authorizing")
+        await self._request(
+            "AUTHORIZE",
+            {
+                "client_id": STREAMKIT_CLIENT_ID,
+                "scopes": list(OAUTH_SCOPES),
+                "prompt": "none",
+            },
+            kind="authorize",
+        )
+
+    async def _handle_discord_payload(self, payload: dict[str, Any]) -> None:
+        nonce = payload.get("nonce")
+        event = payload.get("evt")
+
+        if event == "ERROR":
+            pending = self.pending.pop(str(nonce), None) if nonce is not None else None
+            message = str(payload.get("data", {}).get("message") or "Discord RPC error")
+            kind = pending["kind"] if pending else ""
+            if kind == "authenticate":
+                self.tokens.clear()
+                self.active_token = None
+                self.authenticated = False
+                self._set_status(
+                    "auth_required", "Authorization expired; authorize Discord again"
+                )
+            elif kind == "authorize":
+                self._set_status("auth_required", message)
+            elif kind == "saved_channel":
+                channel_id = pending["meta"]["channel_id"]
+                self.saved_channel_counts[channel_id] = 0
+                self._emit_snapshot()
+            elif kind == "mic_volume":
+                meta = pending["meta"]
+                target = meta["target_volume"]
+                if self.voice_settings["input_volume"] == target:
+                    self.voice_settings["input_volume"] = meta["previous_volume"]
+                self.status_message = message
+                self._emit_snapshot()
+            elif kind == "user_voice_settings":
+                meta = pending["meta"]
+                user_id = meta["user_id"]
+                participant = self.participants.get(user_id)
+                target = meta["target_volume"]
+                if participant and participant["volume"] == target:
+                    participant["volume"] = meta["previous_volume"]
+                self.status_message = message
+                self._emit_snapshot()
+            else:
+                self.status_message = message
+                self._emit_snapshot()
+            return
+
+        if nonce is not None and str(nonce) in self.pending:
+            pending = self.pending.pop(str(nonce))
+            await self._handle_response(pending, payload.get("data"))
+            return
+
+        if payload.get("cmd") == "DISPATCH" and isinstance(event, str):
+            data = payload.get("data")
+            await self._handle_dispatch(event, data if isinstance(data, dict) else {})
+
+    async def _handle_response(self, pending: dict[str, Any], data: Any) -> None:
+        kind = pending["kind"]
+        response = data if isinstance(data, dict) else {}
+
+        if kind == "authorize":
+            code = response.get("code")
+            if not isinstance(code, str) or not code:
+                self._set_status(
+                    "auth_required", "Discord authorization was not completed"
+                )
+                return
+            try:
+                token = await asyncio.to_thread(exchange_authorization_code, code)
+            except Exception as error:
+                self._set_status(
+                    "auth_required", f"StreamKit token exchange failed: {error}"
+                )
+                return
+            self.active_token = token
+            self._set_status("authenticating")
+            await self._request(
+                "AUTHENTICATE", {"access_token": token}, kind="authenticate"
+            )
+            return
+
+        if kind == "authenticate":
+            user = (
+                response.get("user") if isinstance(response.get("user"), dict) else {}
+            )
+            self.current_user = {
+                "id": str(user.get("id") or ""),
+                "username": str(user.get("global_name") or user.get("username") or ""),
+            }
+            self.authenticated = True
+            if self.active_token:
+                self.tokens.save(self.active_token)
+            self._set_status("ready")
+            await self._subscribe_global_events()
+            await self._request("GET_SELECTED_VOICE_CHANNEL", kind="selected_channel")
+            await self._request("GET_VOICE_SETTINGS", kind="voice_settings")
+            return
+
+        if kind == "selected_channel":
+            if response.get("id"):
+                await self._enter_channel(response)
+            else:
+                await self._leave_channel()
+            return
+
+        if kind == "saved_channel":
+            channel_id = pending["meta"]["channel_id"]
+            voice_states = response.get("voice_states")
+            users: set[str] = set()
+            if isinstance(voice_states, list):
+                for state in voice_states:
+                    if not isinstance(state, dict):
+                        continue
+                    user = state.get("user")
+                    user_id = str(
+                        (user.get("id") if isinstance(user, dict) else "")
+                        or state.get("user_id")
+                        or ""
+                    )
+                    if user_id:
+                        users.add(user_id)
+            self.saved_channel_counts[channel_id] = len(users)
+            self._emit_snapshot()
+            return
+
+        if kind == "guild":
+            guild_id = pending["meta"]["guild_id"]
+            if self.channel and self.channel["guild_id"] == guild_id:
+                self.channel["guild_name"] = str(response.get("name") or "")
+                self._remember_current_channel()
+                self._emit_snapshot()
+            return
+
+        if kind in ("voice_settings", "mic_volume"):
+            input_settings = (
+                response.get("input") if isinstance(response.get("input"), dict) else {}
+            )
+            self.voice_settings = {
+                "mute": bool(
+                    response.get("mute", self.voice_settings["mute"])
+                ),
+                "deaf": bool(
+                    response.get("deaf", self.voice_settings["deaf"])
+                ),
+                "input_volume": normalized_volume(
+                    input_settings.get("volume"),
+                    self.voice_settings["input_volume"],
+                    100,
+                ),
+            }
+            self.status_message = ""
+            self._emit_snapshot()
+            return
+
+        if kind == "user_voice_settings":
+            user_id = response.get("user_id") or pending["meta"]["user_id"]
+            participant = self.participants.get(user_id)
+            if participant:
+                participant["volume"] = normalized_volume(
+                    response.get("volume"), participant["volume"], 200
+                )
+                if "mute" in response:
+                    participant["local_mute"] = bool(response["mute"])
+                self.status_message = ""
+                self._emit_snapshot()
+            return
+
+        if kind == "hang_up":
+            if not response:
+                await self._leave_channel()
+            return
+
+        if kind == "join_channel":
+            if response.get("id"):
+                await self._enter_channel(response)
+            else:
+                await self._request(
+                    "GET_SELECTED_VOICE_CHANNEL", kind="selected_channel"
+                )
+
+    async def _subscribe_global_events(self) -> None:
+        for event in (
+            "VOICE_CHANNEL_SELECT",
+            "VOICE_SETTINGS_UPDATE",
+            "VOICE_CONNECTION_STATUS",
+        ):
+            await self._subscribe(event)
+
+    def _saved_channel_ids(self) -> list[str]:
+        channel_ids: list[str] = []
+        seen: set[str] = set()
+        for channel in (*self.favorite_channels, *self.recent_channels):
+            channel_id = channel["id"]
+            if channel_id not in seen:
+                seen.add(channel_id)
+                channel_ids.append(channel_id)
+        return channel_ids
+
+    async def _subscribe_channel_event(self, channel_id: str, event: str) -> None:
+        await self._subscribe(
+            event,
+            {"channel_id": channel_id},
+            meta={"channel_id": channel_id},
+        )
+        self.channel_event_subscriptions.setdefault(channel_id, set()).add(event)
+
+    async def _unsubscribe_channel_event(self, channel_id: str, event: str) -> None:
+        await self._unsubscribe(event, {"channel_id": channel_id})
+        subscribed = self.channel_event_subscriptions.get(channel_id)
+        if subscribed is None:
+            return
+        subscribed.discard(event)
+        if not subscribed:
+            self.channel_event_subscriptions.pop(channel_id, None)
+
+    async def _sync_channel_subscriptions(self) -> None:
+        if not self.authenticated:
+            return
+        desired: dict[str, set[str]] = {}
+        if self.channel:
+            desired[self.channel["id"]] = set((*VOICE_STATE_EVENTS, *SPEAKING_EVENTS))
+        else:
+            for channel_id in self._saved_channel_ids():
+                desired[channel_id] = {"VOICE_STATE_CREATE", "VOICE_STATE_DELETE"}
+
+        for channel_id, events in list(self.channel_event_subscriptions.items()):
+            for event in events - desired.get(channel_id, set()):
+                await self._unsubscribe_channel_event(channel_id, event)
+        for channel_id, events in desired.items():
+            subscribed = self.channel_event_subscriptions.get(channel_id, set())
+            for event in events - subscribed:
+                await self._subscribe_channel_event(channel_id, event)
+
+        await self._refresh_saved_channel_counts()
+
+    async def _refresh_saved_channel_counts(self) -> None:
+        if not self.authenticated or self.channel is not None:
+            return
+        pending_ids = {
+            item["meta"]["channel_id"]
+            for item in self.pending.values()
+            if item["kind"] == "saved_channel"
+        }
+        for channel_id in self._saved_channel_ids():
+            if channel_id not in pending_ids:
+                await self._request(
+                    "GET_CHANNEL",
+                    {"channel_id": channel_id},
+                    kind="saved_channel",
+                    meta={"channel_id": channel_id},
+                )
+
+    async def _enter_channel(self, channel_data: dict[str, Any]) -> None:
+        channel_id = str(channel_data.get("id") or "")
+        if not channel_id:
+            return
+        previous_id = self.channel["id"] if self.channel else ""
+        previous_last_joined = (
+            self.channel["last_joined_time"] if self.channel else 0
+        )
+
+        guild_id = str(channel_data.get("guild_id") or "")
+        known_guild_name = ""
+        for known in (self.channel, *self.favorite_channels, *self.recent_channels):
+            if known and known["guild_id"] == guild_id:
+                known_guild_name = known["guild_name"]
+                if known_guild_name:
+                    break
+        self.channel = {
+            "id": channel_id,
+            "name": str(channel_data.get("name") or "Voice channel"),
+            "guild_id": guild_id,
+            "guild_name": str(channel_data.get("guild_name") or known_guild_name),
+            "last_joined_time": (
+                int(time.time()) if previous_id != channel_id else previous_last_joined
+            ),
+        }
+        if previous_id != channel_id:
+            self.connected_since = int(time.time())
+        self.participants.clear()
+        voice_states = channel_data.get("voice_states")
+        if isinstance(voice_states, list):
+            for state in voice_states:
+                if isinstance(state, dict):
+                    self._upsert_participant(state)
+
+        self._remember_current_channel()
+
+        await self._sync_channel_subscriptions()
+        if guild_id:
+            await self._request(
+                "GET_GUILD",
+                {"guild_id": guild_id},
+                kind="guild",
+                meta={"guild_id": guild_id},
+            )
+        await self._request("GET_VOICE_SETTINGS", kind="voice_settings")
+        self._emit_snapshot()
+
+    def _remember_current_channel(self) -> None:
+        if not self.channel:
+            return
+        channel_id = self.channel["id"]
+        self.recent_channels = [
+            dict(self.channel),
+            *[
+                channel
+                for channel in self.recent_channels
+                if channel["id"] != channel_id
+            ],
+        ][:MAX_RECENT_CHANNELS]
+        self.favorite_channels = [
+            dict(self.channel) if channel["id"] == channel_id else channel
+            for channel in self.favorite_channels
+        ]
+        self.channels.save(self.recent_channels, self.favorite_channels)
+
+    async def _leave_channel(self) -> None:
+        self.channel = None
+        self.participants.clear()
+        self.connected_since = None
+        self.connection = {
+            "state": "DISCONNECTED",
+            "hostname": "",
+            "average_ping": 0,
+            "last_ping": 0,
+        }
+        await self._sync_channel_subscriptions()
+        self._emit_snapshot()
+
+    def _upsert_participant(self, data: dict[str, Any]) -> None:
+        user = data.get("user") if isinstance(data.get("user"), dict) else {}
+        voice = (
+            data.get("voice_state") if isinstance(data.get("voice_state"), dict) else {}
+        )
+        user_id = str(user.get("id") or data.get("user_id") or "")
+        if not user_id:
+            return
+
+        existing = self.participants.get(user_id, {})
+        avatar_hash = str(user.get("avatar") or existing.get("avatar_hash") or "")
+        username = str(
+            user.get("global_name")
+            or user.get("username")
+            or existing.get("username")
+            or "Unknown"
+        )
+        participant = {
+            "id": user_id,
+            "username": username,
+            "nick": str(data.get("nick") or existing.get("nick") or username),
+            "avatar_hash": avatar_hash,
+            "avatar_path": str(existing.get("avatar_path") or ""),
+            "mute": bool(voice.get("mute", existing.get("mute", False))),
+            "self_mute": bool(voice.get("self_mute", existing.get("self_mute", False))),
+            "deaf": bool(voice.get("deaf", existing.get("deaf", False))),
+            "self_deaf": bool(voice.get("self_deaf", existing.get("self_deaf", False))),
+            "volume": normalized_volume(
+                data.get("volume"), int(existing.get("volume", 100)), 200
+            ),
+            "local_mute": bool(data.get("mute", existing.get("local_mute", False))),
+            "speaking": bool(existing.get("speaking", False)),
+        }
+        self.participants[user_id] = participant
+        self._ensure_avatar(user_id, avatar_hash)
+
+    def _ensure_avatar(self, user_id: str, avatar_hash: str) -> None:
+        if not avatar_hash:
+            return
+        destination = avatar_directory() / f"{user_id}-{avatar_hash}.png"
+        participant = self.participants[user_id]
+        if destination.exists():
+            participant["avatar_path"] = str(destination)
+            return
+        key = f"{user_id}:{avatar_hash}"
+        if key in self.avatar_tasks:
+            return
+
+        async def hydrate() -> None:
+            try:
+                path = await asyncio.to_thread(
+                    download_avatar, user_id, avatar_hash, destination
+                )
+                current = self.participants.get(user_id)
+                if current and current.get("avatar_hash") == avatar_hash:
+                    current["avatar_path"] = str(path)
+                    self._emit_snapshot()
+            except Exception as error:
+                log.info("Could not cache avatar for user %s: %s", user_id, error)
+            finally:
+                self.avatar_tasks.pop(key, None)
+
+        self.avatar_tasks[key] = asyncio.create_task(hydrate())
+
+    async def _handle_dispatch(self, event: str, data: dict[str, Any]) -> None:
+        if event == "VOICE_CHANNEL_SELECT":
+            if data.get("channel_id"):
+                await self._request(
+                    "GET_SELECTED_VOICE_CHANNEL", kind="selected_channel"
+                )
+            else:
+                await self._leave_channel()
+            return
+
+        if event == "VOICE_SETTINGS_UPDATE":
+            input_settings = (
+                data.get("input") if isinstance(data.get("input"), dict) else {}
+            )
+            self.voice_settings = {
+                "mute": bool(data.get("mute", self.voice_settings["mute"])),
+                "deaf": bool(data.get("deaf", self.voice_settings["deaf"])),
+                "input_volume": normalized_volume(
+                    input_settings.get("volume"),
+                    self.voice_settings["input_volume"],
+                    100,
+                ),
+            }
+            self._emit_snapshot()
+            return
+
+        if event == "VOICE_CONNECTION_STATUS":
+            self.connection = {
+                "state": str(data.get("state") or "DISCONNECTED"),
+                "hostname": str(data.get("hostname") or ""),
+                "average_ping": int(float(data.get("average_ping") or 0)),
+                "last_ping": int(float(data.get("last_ping") or 0)),
+            }
+            self._emit_snapshot()
+            return
+
+        if event in ("VOICE_STATE_CREATE", "VOICE_STATE_UPDATE"):
+            if self.channel:
+                self._upsert_participant(data)
+                self._emit_snapshot()
+            else:
+                await self._refresh_saved_channel_counts()
+            return
+
+        if event == "VOICE_STATE_DELETE":
+            if self.channel:
+                user = data.get("user") if isinstance(data.get("user"), dict) else {}
+                user_id = str(user.get("id") or data.get("user_id") or "")
+                if user_id:
+                    self.participants.pop(user_id, None)
+                    self._emit_snapshot()
+            else:
+                await self._refresh_saved_channel_counts()
+            return
+
+        if event in ("SPEAKING_START", "SPEAKING_STOP"):
+            user_id = str(data.get("user_id") or "")
+            participant = self.participants.get(user_id)
+            if participant:
+                participant["speaking"] = event == "SPEAKING_START"
+                self._emit_snapshot()
+
+
+async def send_control_command(
+    command: str, value: Any = None, user_id: str | None = None
+) -> dict[str, Any]:
+    request: dict[str, Any] = {"command": command}
+    if value is not None:
+        request["value"] = value
+    if user_id is not None:
+        request["user_id"] = user_id
+    reader, writer = await asyncio.wait_for(
+        asyncio.open_unix_connection(str(control_socket_path())), timeout=3
+    )
+    writer.write(json.dumps(request, separators=(",", ":")).encode("utf-8") + b"\n")
+    await writer.drain()
+    encoded = await asyncio.wait_for(reader.readline(), timeout=5)
+    writer.close()
+    try:
+        await writer.wait_closed()
+    except OSError:
+        pass
+    return json.loads(encoded.decode("utf-8"))
+
+
+def main() -> int:
+    if len(sys.argv) < 2 or sys.argv[1] not in ("daemon", "command"):
+        print(
+            "usage: discord_bridge.py daemon | command <name> [value] [volume]",
+            file=sys.stderr,
+        )
+        return 2
+
+    if sys.argv[1] == "daemon":
+        try:
+            asyncio.run(DiscordVoiceBridge().run())
+            return 0
+        except Exception as error:
+            log.error("Bridge failed: %s", error)
+            return 1
+
+    if len(sys.argv) < 3:
+        print(json.dumps({"ok": False, "error": "missing command"}))
+        return 2
+
+    command = sys.argv[2].replace("-", "_")
+
+    try:
+        user_id: str | None = None
+        if command in ("set_mute", "set_deaf"):
+            value: Any = sys.argv[3] == "true"
+        elif command == "set_mic_volume":
+            value = int(sys.argv[3])
+        elif command == "set_user_volume":
+            user_id = sys.argv[3]
+            value = int(sys.argv[4])
+        elif command in ("favorite_channel", "unfavorite_channel", "join_channel"):
+            value = sys.argv[3]
+        else:
+            value = None
+    except (IndexError, ValueError) as error:
+        detail = (
+            "missing required value" if isinstance(error, IndexError) else str(error)
+        )
+        print(
+            json.dumps(
+                {
+                    "ok": False,
+                    "error": f"invalid arguments for {sys.argv[2]}: {detail}",
+                },
+                separators=(",", ":"),
+            )
+        )
+        return 2
+
+    try:
+        response = asyncio.run(send_control_command(command, value, user_id))
+    except Exception as error:
+        response = {
+            "ok": False,
+            "error": f"Discord voice bridge is unavailable: {error}",
+        }
+    print(json.dumps(response, separators=(",", ":")))
+    return 0 if response.get("ok") else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/discord-voice/panel.luau b/discord-voice/panel.luau
new file mode 100644
index 00000000..39e2c373
--- /dev/null
+++ b/discord-voice/panel.luau
@@ -0,0 +1,614 @@
+--!nonstrict
+
+local snapshot = noctalia.state.get("voice_snapshot") or {
+  status = "starting",
+  status_message = "",
+  authenticated = false,
+  user = {},
+  channel = nil,
+  recent_channels = {},
+  favorite_channels = {},
+  participants = {},
+  voice = { mute = false, deaf = false, input_volume = 100 },
+  connection = { state = "DISCONNECTED", average_ping = 0, last_ping = 0, hostname = "" },
+  connected_since = nil,
+}
+local isOpen = false
+local actionPending = false
+local actionError = ""
+
+local render
+local ACTION_BUTTON_WIDTH = 112
+local CENTERED_LAYOUT = { flexGrow = 1, align = "center", justify = "center", gap = 10, padding = 20 }
+local micVolumeDraft = snapshot.voice.input_volume
+local micVolumeEditing = false
+local participantVolumeDraft = {}
+local participantVolumeEditing = {}
+
+local tr = noctalia.tr
+
+local function quoteShellArgument(value)
+  return "'" .. value:gsub("'", "'\\''") .. "'"
+end
+
+local function discordBinary()
+  local configured = noctalia.getConfig("discord_binary")
+  if type(configured) == "string" and configured ~= "" then
+    return configured
+  end
+  return "/usr/bin/discord"
+end
+
+local function openDiscord()
+  local binary = quoteShellArgument(discordBinary())
+  local channel = snapshot.channel
+  if channel == nil then
+    noctalia.runAsync(binary)
+    return
+  end
+  local guildId = channel.guild_id
+  local channelId = channel.id
+  if guildId ~= "" and channelId ~= "" then
+    local uri = `discord://-/channels/{guildId}/{channelId}`
+    noctalia.runAsync(binary .. " --url -- " .. quoteShellArgument(uri))
+  else
+    noctalia.runAsync(binary)
+  end
+end
+
+local function durationText()
+  local since = snapshot.connected_since
+  if since == nil then
+    return "—"
+  end
+  local total = math.max(0, (tonumber(noctalia.formatTime("%s")) or 0) - since)
+  local hours = math.floor(total / 3600)
+  local minutes = math.floor((total % 3600) / 60)
+  local seconds = math.floor(total % 60)
+  if hours > 0 then
+    return string.format("%d:%02d:%02d", hours, minutes, seconds)
+  end
+  return string.format("%d:%02d", minutes, seconds)
+end
+
+local function appendCommandArgument(command, value)
+  if value == nil then
+    return command
+  end
+  if type(value) == "boolean" then
+    return command .. (value and " true" or " false")
+  end
+  return command .. " " .. quoteShellArgument(tostring(value))
+end
+
+local function runBridgeCommand(name, value, secondValue)
+  if actionPending then
+    return
+  end
+  actionPending = true
+  actionError = ""
+  render()
+
+  local script = noctalia.pluginDir() .. "/discord_bridge.py"
+  local command = "python3 " .. quoteShellArgument(script) .. " command " .. name
+  command = appendCommandArgument(command, value)
+  command = appendCommandArgument(command, secondValue)
+  local started = noctalia.runAsync(command, function(result)
+    actionPending = false
+    local decoded = noctalia.json.decode(result.stdout or "")
+    if result.exitCode ~= 0 then
+      if type(decoded) == "table" and type(decoded.error) == "string" then
+        actionError = decoded.error
+      else
+        local message = noctalia.string.trim(result.stderr or ""):match("^[^\r\n]+") or ""
+        actionError = message ~= "" and message or tr("error.command")
+      end
+    end
+    render()
+  end)
+  if not started then
+    actionPending = false
+    actionError = tr("error.command")
+    render()
+  end
+end
+
+local function roundedVolume(value, maximum)
+  return math.max(0, math.min(maximum, math.floor(value + 0.5)))
+end
+
+local function syncVolumeDrafts()
+  if not micVolumeEditing then
+    micVolumeDraft = roundedVolume(snapshot.voice.input_volume, 100)
+  end
+  local present = {}
+  for _, participant in ipairs(snapshot.participants) do
+    local userId = participant.id
+    present[userId] = true
+    if not participantVolumeEditing[userId] then
+      participantVolumeDraft[userId] = roundedVolume(participant.volume, 200)
+    end
+  end
+  for userId, _ in pairs(participantVolumeDraft) do
+    if not present[userId] then
+      participantVolumeDraft[userId] = nil
+      participantVolumeEditing[userId] = nil
+    end
+  end
+end
+
+local function changeMicVolume(value)
+  micVolumeEditing = true
+  micVolumeDraft = roundedVolume(value, 100)
+  render()
+end
+
+local function commitMicVolume()
+  micVolumeEditing = false
+  runBridgeCommand("set-mic-volume", micVolumeDraft)
+end
+
+local function changeParticipantVolume(userId, value)
+  participantVolumeEditing[userId] = true
+  participantVolumeDraft[userId] = roundedVolume(value, 200)
+  render()
+end
+
+local function commitParticipantVolume(userId)
+  local volume = participantVolumeDraft[userId]
+  participantVolumeEditing[userId] = false
+  runBridgeCommand("set-user-volume", userId, volume)
+end
+
+local function connectionAppearance()
+  local connection = snapshot.connection
+  local state = connection.state
+  local ping = connection.average_ping
+  if state == "VOICE_CONNECTED" then
+    if ping <= 0 then
+      return "wifi", "primary", tr("connection.connected")
+    elseif ping <= 60 then
+      return "wifi", "primary", tr("connection.ping", { ping = math.floor(ping) })
+    elseif ping <= 120 then
+      return "wifi", "tertiary", tr("connection.ping", { ping = math.floor(ping) })
+    end
+    return "wifi", "error", tr("connection.ping", { ping = math.floor(ping) })
+  elseif state == "NO_ROUTE" then
+    return "wifi-off", "error", tr("connection.no_route")
+  elseif state == "DISCONNECTED" or state == "VOICE_DISCONNECTED" then
+    return "wifi-off", "on_surface_variant", tr("connection.disconnected")
+  end
+  return "loader-2", "tertiary", tr("connection.connecting")
+end
+
+local function participantVisual(participant)
+  local speaking = participant.speaking
+  if participant.avatar_path ~= "" then
+    return ui.image({
+      key = "avatar:" .. participant.id,
+      path = participant.avatar_path,
+      width = 36,
+      height = 36,
+      radius = 18,
+      fit = "cover",
+      border = speaking and "primary" or "outline",
+      borderWidth = speaking and 2 or 1,
+    })
+  end
+  return ui.glyph({
+    key = "avatar-fallback:" .. participant.id,
+    name = "user-circle",
+    size = 36,
+    color = speaking and "primary" or "on_surface_variant",
+  })
+end
+
+local function participantRow(participant)
+  local speaking = participant.speaking
+  local displayName = participant.nick
+  if participant.id == snapshot.user.id then
+    displayName ..= " " .. tr("participant.you")
+  end
+  local isSelf = participant.id == snapshot.user.id
+  local muted = participant.mute or participant.self_mute or participant.local_mute
+  local deafened = participant.deaf or participant.self_deaf
+
+  local indicators = {}
+  if speaking then
+    table.insert(indicators, ui.glyph({ name = "volume", size = 15, color = "primary" }))
+  end
+  if muted then
+    table.insert(indicators, ui.glyph({ name = "microphone-off", size = 15, color = "error" }))
+  end
+  if deafened then
+    table.insert(indicators, ui.glyph({ name = "headphones-off", size = 15, color = "error" }))
+  end
+
+  local participantDetails = {
+    ui.row({ align = "center", gap = 6 }, {
+      ui.label({
+        text = displayName,
+        color = speaking and "primary" or "on_surface",
+        fontWeight = speaking and "bold" or "medium",
+        flexGrow = 1,
+        maxLines = 1,
+      }),
+      ui.label({
+        text = speaking and tr("participant.speaking") or tr("participant.listening"),
+        color = "on_surface_variant",
+        fontSize = 10,
+      }),
+      ui.row({ gap = 4, align = "center" }, indicators),
+    }),
+  }
+
+  local userId = participant.id
+  local volume = isSelf
+    and roundedVolume(micVolumeDraft, 100)
+    or (participantVolumeDraft[userId] or roundedVolume(participant.volume, 200))
+  local maximum = isSelf and 100 or 200
+  local volumeGlyph = isSelf
+    and (volume == 0 and "microphone-off" or "microphone")
+    or (volume == 0 and "volume-off" or "volume")
+  table.insert(participantDetails, ui.row({ gap = 6, align = "center" }, {
+    ui.glyph({ name = volumeGlyph, size = 13, color = "on_surface_variant" }),
+    ui.slider({
+      key = "participant-volume:" .. userId,
+      min = 0,
+      max = maximum,
+      step = 1,
+      value = volume,
+      enabled = not actionPending,
+      flexGrow = 1,
+      onChange = function(value)
+        if isSelf then
+          changeMicVolume(value)
+        else
+          changeParticipantVolume(userId, value)
+        end
+      end,
+      onDragEnd = function()
+        if isSelf then
+          commitMicVolume()
+        else
+          commitParticipantVolume(userId)
+        end
+      end,
+    }),
+    ui.label({ text = tostring(volume) .. "%", width = 38, fontSize = 10, color = "on_surface_variant", textAlign = "end" }),
+  }))
+
+  return ui.row({
+    key = "participant:" .. participant.id,
+    gap = 10,
+    align = "center",
+    paddingH = 10,
+    paddingV = 6,
+    fill = speaking and "primary/0.10" or "surface_variant/0.24",
+    border = speaking and "primary/0.55" or "outline/0.32",
+    borderWidth = 1,
+    radius = 11,
+  }, {
+    participantVisual(participant),
+    ui.column({ gap = 1, flexGrow = 1, align = "stretch" }, participantDetails),
+  })
+end
+
+local function participantList()
+  local rows = {}
+  for _, participant in ipairs(snapshot.participants) do
+    table.insert(rows, participantRow(participant))
+  end
+  if #rows == 0 then
+    table.insert(rows, ui.column({ paddingV = 20, align = "center" }, {
+      ui.label({
+        text = tr("participants.empty"),
+        color = "on_surface_variant",
+        textAlign = "center",
+      }),
+    }))
+  end
+  return rows
+end
+
+local function recentChannelRow(channel, favorite)
+  local serverName = channel.guild_name ~= "" and channel.guild_name or tr("unknown_server")
+  local participantCount = channel.participant_count
+  local children = {
+    ui.button({
+      glyph = favorite and "star-filled" or "star",
+      variant = "ghost",
+      selected = favorite,
+      enabled = not actionPending,
+      onClick = function()
+        runBridgeCommand(favorite and "unfavorite-channel" or "favorite-channel", channel.id)
+      end,
+    }),
+    ui.label({ text = serverName, width = 120, fontWeight = "bold", color = "primary", maxLines = 1 }),
+    ui.label({ text = "/", color = "on_surface_variant" }),
+    ui.label({ text = channel.name, color = "on_surface_variant", flexGrow = 1, maxLines = 1 }),
+  }
+  if participantCount > 0 then
+    table.insert(children, ui.row({ gap = 4, align = "center" }, {
+      ui.glyph({ name = "users", size = 14, color = "primary" }),
+      ui.label({ text = tostring(participantCount), fontSize = 12, fontWeight = "bold", color = "primary" }),
+    }))
+  end
+  table.insert(children, ui.button({
+    text = tr("saved.join"),
+    glyph = "phone",
+    variant = "primary",
+    width = ACTION_BUTTON_WIDTH,
+    enabled = not actionPending,
+    onClick = function()
+      runBridgeCommand("join-channel", channel.id)
+    end,
+  }))
+  return ui.row({
+    key = "recent:" .. channel.id,
+    fill = "surface_variant/0.26",
+    border = "outline/0.34",
+    borderWidth = 1,
+    radius = 10,
+    paddingH = 10,
+    paddingV = 8,
+    gap = 7,
+    align = "center",
+  }, children)
+end
+
+local function recentChannelRows()
+  local rows = {}
+  local favoriteIds = {}
+
+  for _, channel in ipairs(snapshot.favorite_channels) do
+    favoriteIds[channel.id] = true
+    table.insert(rows, recentChannelRow(channel, true))
+  end
+
+  for _, channel in ipairs(snapshot.recent_channels) do
+    if not favoriteIds[channel.id] then
+      table.insert(rows, recentChannelRow(channel, false))
+    end
+  end
+
+  if #rows == 0 then
+    table.insert(rows, ui.column({ paddingV = 12, align = "center" }, {
+      ui.label({ text = tr("saved.empty"), color = "on_surface_variant", textAlign = "center" }),
+    }))
+  end
+  return rows
+end
+
+local function disconnectedBody()
+  local status = snapshot.status
+  local message = snapshot.status_message
+  if status == "auth_required" then
+    local children = {
+      ui.glyph({ name = "brand-discord", size = 46, color = "primary" }),
+      ui.label({ text = tr("auth.title"), fontSize = 17, fontWeight = "bold", color = "on_surface" }),
+      ui.label({ text = message ~= "" and message or tr("auth.description"), color = "on_surface_variant", textAlign = "center", maxLines = 4 }),
+      ui.button({
+        text = tr("auth.button"),
+        glyph = "external-link",
+        variant = "primary",
+        enabled = not actionPending,
+        onClick = function()
+          runBridgeCommand("authorize")
+        end,
+      }),
+    }
+    return ui.column(CENTERED_LAYOUT, children)
+  elseif status == "authorizing" or status == "authenticating" then
+    return ui.column(CENTERED_LAYOUT, {
+      ui.glyph({ name = "loader-2", size = 42, color = "primary" }),
+      ui.label({ text = tr("auth.waiting"), fontWeight = "bold", color = "on_surface" }),
+      ui.label({ text = tr("auth.waiting_description"), color = "on_surface_variant", textAlign = "center" }),
+    })
+  elseif status == "discord_unavailable" then
+    return ui.column(CENTERED_LAYOUT, {
+      ui.glyph({ name = "brand-discord", size = 46, color = "on_surface_variant" }),
+      ui.label({ text = tr("offline.title"), fontSize = 17, fontWeight = "bold", color = "on_surface" }),
+      ui.label({ text = message ~= "" and message or tr("offline.description"), color = "on_surface_variant", textAlign = "center", maxLines = 4 }),
+      ui.button({ text = tr("open_discord"), glyph = "brand-discord", variant = "primary", onClick = openDiscord }),
+    })
+  elseif status == "error" then
+    return ui.column(CENTERED_LAYOUT, {
+      ui.glyph({ name = "alert-circle", size = 42, color = "error" }),
+      ui.label({ text = tr("error.title"), fontWeight = "bold", color = "error" }),
+      ui.label({ text = message, color = "on_surface_variant", textAlign = "center", maxLines = 4 }),
+    })
+  end
+  return ui.column(CENTERED_LAYOUT, {
+    ui.glyph({ name = "loader-2", size = 42, color = "primary" }),
+    ui.label({ text = tr("starting"), color = "on_surface_variant" }),
+  })
+end
+
+local function voiceBody()
+  if snapshot.channel == nil then
+    return ui.column({ flexGrow = 1, gap = 10, align = "stretch", padding = 4 }, {
+      ui.row({
+        align = "center",
+        justify = "center",
+        gap = 8,
+        paddingH = 12,
+        paddingV = 12,
+        fill = "surface_variant/0.24",
+        border = "outline/0.34",
+        borderWidth = 1,
+        radius = 11,
+      }, {
+        ui.glyph({ name = "headphones", size = 20, color = "on_surface_variant" }),
+        ui.label({ text = tr("not_in_voice.title"), fontSize = 15, fontWeight = "bold", color = "on_surface" }),
+      }),
+      ui.row({ align = "center", gap = 8, paddingH = 2 }, {
+        ui.glyph({ name = "history", size = 18, color = "primary" }),
+        ui.label({ text = tr("saved.channels"), fontSize = 16, fontWeight = "bold", color = "on_surface", flexGrow = 1 }),
+        ui.button({ glyph = "external-link", variant = "ghost", onClick = openDiscord }),
+      }),
+      ui.scroll({ flexGrow = 1, gap = 8, align = "stretch" }, recentChannelRows()),
+    })
+  end
+
+  local channel = snapshot.channel
+  local voice = snapshot.voice
+  local connectionGlyph, connectionColor, connectionLabel = connectionAppearance()
+  local serverName = channel.guild_name ~= "" and channel.guild_name or tr("unknown_server")
+  local participants = snapshot.participants
+  local favorite = false
+  for _, savedChannel in ipairs(snapshot.favorite_channels) do
+    if savedChannel.id == channel.id then
+      favorite = true
+      break
+    end
+  end
+
+  return ui.column({ flexGrow = 1, gap = 12, align = "stretch" }, {
+    ui.column({
+      fill = "surface_variant/0.24",
+      border = "outline/0.38",
+      borderWidth = 1,
+      radius = 13,
+      padding = 13,
+      gap = 8,
+    }, {
+      ui.row({ gap = 8, align = "center" }, {
+        ui.glyph({ name = "server", size = 17, color = "on_surface_variant" }),
+        ui.label({ text = serverName, fontWeight = "bold", color = "on_surface", flexGrow = 1, maxLines = 1 }),
+        ui.button({
+          glyph = favorite and "star-filled" or "star",
+          variant = favorite and "secondary" or "ghost",
+          enabled = not actionPending,
+          onClick = function()
+            runBridgeCommand(favorite and "unfavorite-channel" or "favorite-channel", channel.id)
+          end,
+        }),
+        ui.button({ glyph = "external-link", variant = "ghost", onClick = openDiscord }),
+      }),
+      ui.row({ gap = 8, align = "center" }, {
+        ui.glyph({ name = "volume", size = 18, color = "primary" }),
+        ui.label({ text = channel.name, fontSize = 16, fontWeight = "bold", color = "primary", flexGrow = 1, maxLines = 1 }),
+      }),
+      ui.row({ gap = 14, align = "center" }, {
+        ui.row({ gap = 5, align = "center" }, {
+          ui.glyph({ name = "clock", size = 14, color = "on_surface_variant" }),
+          ui.label({ text = durationText(), fontSize = 12, color = "on_surface_variant" }),
+        }),
+        ui.row({
+          gap = 5,
+          align = "center",
+          fill = connectionColor .. "/0.13",
+          border = connectionColor .. "/0.30",
+          borderWidth = 1,
+          radius = 8,
+          paddingH = 8,
+          paddingV = 3,
+        }, {
+          ui.glyph({ name = connectionGlyph, size = 14, color = connectionColor }),
+          ui.label({ text = connectionLabel, fontSize = 12, color = connectionColor }),
+        }),
+        ui.row({ gap = 5, align = "center" }, {
+          ui.glyph({ name = "users", size = 14, color = "on_surface_variant" }),
+          ui.label({ text = tostring(#participants), fontSize = 12, color = "on_surface_variant" }),
+        }),
+      }),
+    }),
+    ui.row({
+      gap = 9,
+      align = "center",
+      padding = 8,
+      fill = "surface_variant/0.18",
+      border = "outline/0.30",
+      borderWidth = 1,
+      radius = 12,
+    }, {
+      ui.button({
+        text = voice.mute and tr("controls.unmute") or tr("controls.mute"),
+        glyph = voice.mute and "microphone-off" or "microphone",
+        variant = voice.mute and "secondary" or "outline",
+        selected = voice.mute,
+        enabled = not actionPending,
+        flexGrow = 1,
+        onClick = function()
+          runBridgeCommand("set-mute", not voice.mute)
+        end,
+      }),
+      ui.button({
+        text = voice.deaf and tr("controls.undeafen") or tr("controls.deafen"),
+        glyph = voice.deaf and "headphones-off" or "headphones",
+        variant = voice.deaf and "secondary" or "outline",
+        selected = voice.deaf,
+        enabled = not actionPending,
+        flexGrow = 1,
+        onClick = function()
+          runBridgeCommand("set-deaf", not voice.deaf)
+        end,
+      }),
+      ui.button({
+        text = tr("controls.hang_up"),
+        glyph = "phone-off",
+        variant = "destructive",
+        enabled = not actionPending,
+        flexGrow = 1,
+        onClick = function()
+          runBridgeCommand("hang-up")
+        end,
+      }),
+    }),
+    ui.label({ text = tr("participants.title", { count = #participants }), fontSize = 13, fontWeight = "bold", color = "on_surface_variant" }),
+    ui.scroll({ flexGrow = 1, gap = 8, align = "stretch" }, participantList()),
+  })
+end
+
+render = function()
+  if not isOpen then
+    return
+  end
+  local children = {
+    ui.row({ align = "center", justify = "space_between", gap = 8 }, {
+      ui.row({ gap = 8, align = "center", flexGrow = 1 }, {
+        ui.glyph({ name = "brand-discord", size = 20, color = "primary" }),
+        ui.label({ text = tr("title"), fontSize = 17, fontWeight = "bold", color = "on_surface" }),
+      }),
+      ui.button({ glyph = "close", variant = "ghost", onClick = panel.close }),
+    }),
+  }
+  if actionError ~= "" then
+    table.insert(children, ui.label({ text = actionError, fontSize = 11, color = "error", maxLines = 3 }))
+  end
+  local body = snapshot.authenticated and voiceBody() or disconnectedBody()
+  table.insert(children, body)
+  panel.render(ui.column({ flexGrow = 1, gap = 12, align = "stretch" }, children))
+end
+
+noctalia.state.watch("voice_snapshot", function(value)
+  if type(value) == "table" then
+    snapshot = value
+    syncVolumeDrafts()
+    actionError = snapshot.authenticated and snapshot.status_message or ""
+    render()
+  end
+end)
+
+function onOpen(_context)
+  snapshot = noctalia.state.get("voice_snapshot") or snapshot
+  micVolumeEditing = false
+  participantVolumeEditing = {}
+  syncVolumeDrafts()
+  isOpen = true
+  panel.setWantsSecondTicks(true)
+  render()
+  runBridgeCommand("refresh")
+end
+
+function onClose()
+  isOpen = false
+  micVolumeEditing = false
+  participantVolumeEditing = {}
+  panel.setWantsSecondTicks(false)
+end
+
+function update()
+  render()
+end
diff --git a/discord-voice/plugin.toml b/discord-voice/plugin.toml
new file mode 100644
index 00000000..b0217655
--- /dev/null
+++ b/discord-voice/plugin.toml
@@ -0,0 +1,54 @@
+id = "raycursive/discord-voice"
+name = "Discord Voice"
+version = "0.3.1"
+plugin_api = 9
+author = "raycursive"
+license = "MIT"
+dependencies = ["discord", "python3"]
+tags = ["audio", "bar", "network", "panel", "privacy", "service"]
+icon = "brand-discord"
+description = "Monitor and control local Discord voice sessions, including participants, volume, speaking, and latency."
+
+[[setting]]
+key = "discord_binary"
+type = "file"
+label_key = "settings.discord_binary.label"
+description_key = "settings.discord_binary.description"
+default = "/usr/bin/discord"
+
+[[service]]
+id = "bridge"
+entry = "service.luau"
+
+[[widget]]
+id = "bar"
+entry = "bar.luau"
+
+  [[widget.setting]]
+  key = "glyph"
+  type = "glyph"
+  label_key = "settings.glyph.label"
+  default = "brand-discord"
+
+  [[widget.setting]]
+  key = "show_channel_name"
+  type = "bool"
+  label_key = "settings.show_channel_name.label"
+  description_key = "settings.show_channel_name.description"
+  default = true
+
+  [[widget.setting]]
+  key = "hide_when_disconnected"
+  type = "bool"
+  label_key = "settings.hide_when_disconnected.label"
+  description_key = "settings.hide_when_disconnected.description"
+  default = false
+
+[[panel]]
+id = "panel"
+entry = "panel.luau"
+width = 600
+height = 640
+placement = "attached"
+position = "auto"
+open_near_click = true
diff --git a/discord-voice/service.luau b/discord-voice/service.luau
new file mode 100644
index 00000000..6351fe62
--- /dev/null
+++ b/discord-voice/service.luau
@@ -0,0 +1,118 @@
+--!nonstrict
+-- Headless service: owns the long-lived Python bridge and publishes each
+-- complete Discord voice snapshot for the widget and panel.
+
+local BRIDGE_STATE_KEY = "voice_snapshot"
+
+local bridgePath = noctalia.pluginDir() .. "/discord_bridge.py"
+local bridgeScript = "'" .. bridgePath:gsub("'", "'\\''") .. "'"
+
+local function initialSnapshot(status, message)
+  return {
+    revision = 0,
+    status = status,
+    status_message = message,
+    authenticated = false,
+    user = {},
+    channel = nil,
+    recent_channels = {},
+    favorite_channels = {},
+    participants = {},
+    voice = { mute = false, deaf = false, input_volume = 100 },
+    connection = {
+      state = "DISCONNECTED",
+      hostname = "",
+      average_ping = 0,
+      last_ping = 0,
+    },
+    connected_since = nil,
+  }
+end
+
+local function shallowCopy(value)
+  local copy = {}
+  for key, item in pairs(value) do
+    copy[key] = item
+  end
+  return copy
+end
+
+local lastLineAt = tonumber(noctalia.formatTime("%s")) or 0
+local streamStarted = false
+
+local function onBridgeLine(line)
+  lastLineAt = tonumber(noctalia.formatTime("%s")) or 0
+  local event, err = noctalia.json.decode(line)
+  if type(event) ~= "table" then
+    noctalia.log("discord-voice: ignored malformed bridge output: " .. tostring(err or "unknown error"))
+    return
+  end
+  if event.type == "heartbeat" then
+    return
+  end
+  if event.type ~= "snapshot" then
+    return
+  end
+  event.type = nil
+  noctalia.state.set(BRIDGE_STATE_KEY, event)
+end
+
+local function startBridge()
+  if streamStarted then
+    return
+  end
+  if not noctalia.commandExists("python3") then
+    noctalia.state.set(BRIDGE_STATE_KEY, initialSnapshot("error", noctalia.tr("error.python_missing")))
+    return
+  end
+  noctalia.state.set(BRIDGE_STATE_KEY, initialSnapshot("starting", ""))
+  streamStarted = noctalia.runStream("python3 " .. bridgeScript .. " daemon", onBridgeLine)
+  if streamStarted then
+    lastLineAt = tonumber(noctalia.formatTime("%s")) or 0
+  else
+    noctalia.state.set(BRIDGE_STATE_KEY, initialSnapshot("error", noctalia.tr("error.bridge_start")))
+  end
+end
+
+noctalia.setUpdateInterval(5000)
+startBridge()
+
+function update()
+  -- The bridge emits a heartbeat every five seconds. Surface a stalled helper
+  -- and restart it. This also recovers from a helper that exits during a
+  -- Noctalia hot-reload handoff.
+  if not streamStarted then
+    startBridge()
+    return
+  end
+  if (tonumber(noctalia.formatTime("%s")) or 0) - lastLineAt > 20 then
+    local previous = shallowCopy(noctalia.state.get(BRIDGE_STATE_KEY))
+    previous.status_message = noctalia.tr("error.bridge_stalled")
+    noctalia.state.set(BRIDGE_STATE_KEY, previous)
+    streamStarted = false
+    startBridge()
+  end
+end
+
+function onIpc(event, _payload)
+  if event == "authorize" then
+    noctalia.runAsync("python3 " .. bridgeScript .. " command authorize")
+  elseif event == "refresh" then
+    noctalia.runAsync("python3 " .. bridgeScript .. " command refresh")
+  elseif event == "hangup" then
+    noctalia.runAsync("python3 " .. bridgeScript .. " command hang-up")
+  elseif event == "dump" then
+    local snapshot = noctalia.state.get(BRIDGE_STATE_KEY)
+    local safe = {
+      status = snapshot.status,
+      authenticated = snapshot.authenticated,
+      channel = snapshot.channel,
+      recent_channels = snapshot.recent_channels,
+      favorite_channels = snapshot.favorite_channels,
+      participants = #snapshot.participants,
+      voice = snapshot.voice,
+      connection = snapshot.connection,
+    }
+    noctalia.log("discord-voice: " .. (noctalia.json.encode(safe) or "?"))
+  end
+end
diff --git a/discord-voice/thumbnail.webp b/discord-voice/thumbnail.webp
new file mode 100644
index 0000000000000000000000000000000000000000..4ddd00099b7a533c7458ed0789dc1584fa3785c8
GIT binary patch
literal 40540
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
AQ~&?~

literal 0
HcmV?d00001

diff --git a/discord-voice/translations/en.json b/discord-voice/translations/en.json
new file mode 100644
index 00000000..66ae4270
--- /dev/null
+++ b/discord-voice/translations/en.json
@@ -0,0 +1,79 @@
+{
+  "title": "Discord Voice",
+  "starting": "Connecting to Discord…",
+  "open_discord": "Open in Discord",
+  "unknown_server": "Unknown server",
+  "unknown_user": "Unknown user",
+  "voice_channel": "Voice channel",
+  "settings": {
+    "glyph": {
+      "label": "Bar glyph"
+    },
+    "discord_binary": {
+      "label": "Discord executable",
+      "description": "Discord desktop executable used to launch the app and open the active voice channel."
+    },
+    "show_channel_name": {
+      "label": "Show channel name",
+      "description": "Show the current voice channel beside the Discord glyph."
+    },
+    "hide_when_disconnected": {
+      "label": "Hide outside voice",
+      "description": "Hide the bar widget when no voice channel is connected."
+    }
+  },
+  "bar": {
+    "authorize": "Authorize",
+    "authorizing": "Authorizing…",
+    "offline": "Offline"
+  },
+  "connection": {
+    "connected": "Connected",
+    "connecting": "Connecting",
+    "disconnected": "Disconnected",
+    "no_route": "No route",
+    "ping": "{ping} ms"
+  },
+  "auth": {
+    "title": "Authorize Discord Voice",
+    "description": "Discord will ask you to grant local voice read and control access through its StreamKit integration.",
+    "button": "Authorize Discord",
+    "waiting": "Waiting for Discord",
+    "waiting_description": "Complete the authorization prompt in the Discord desktop app."
+  },
+  "offline": {
+    "title": "Discord is unavailable",
+    "description": "Start the Discord desktop app. The bridge will reconnect automatically."
+  },
+  "not_in_voice": {
+    "title": "Not in an active channel"
+  },
+  "saved": {
+    "channels": "Recent channels",
+    "empty": "Your five most recently joined channels will appear here.",
+    "join": "Join"
+  },
+  "controls": {
+    "mute": "Mute",
+    "unmute": "Unmute",
+    "deafen": "Deafen",
+    "undeafen": "Undeafen",
+    "hang_up": "Hang up"
+  },
+  "participants": {
+    "title": "Participants ({count})",
+    "empty": "Nobody is visible in this channel yet."
+  },
+  "participant": {
+    "you": "(you)",
+    "speaking": "Speaking",
+    "listening": "Listening"
+  },
+  "error": {
+    "title": "Discord voice error",
+    "python_missing": "python3 is required but was not found in PATH.",
+    "bridge_start": "Could not start the Discord voice bridge.",
+    "bridge_stalled": "The Discord voice bridge stopped responding.",
+    "command": "The Discord voice command failed."
+  }
+}