Merge pull request #58 from HueByte/dev

Dev
2026-09-04 08:36:11 +02:00 · 2026-07-16 20:33:43 +02:00
parent 1f4af9a543 584ce45979
commit 4d25458717
42 changed files with 3107 additions and 151 deletions
@@ -14,6 +14,15 @@ jobs:
    steps:
      - uses: actions/checkout@v4
      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: 24
          cache: npm
      - name: Install pinned linter
        run: npm ci
      - name: Run markdownlint
        run: bash scripts/lint-markdown.sh
@@ -101,6 +101,23 @@ Access tokens expire after 15 minutes, refresh tokens after 30 days with rotatio
 | `Server:PublicHost` | *(empty)* | Public hostname for the directory listing (e.g. `chat.example.com:5000`) |
 | `Server:Admins` | `[]` | Array of admin usernames (e.g. `["alice", "bob"]`) |
 ### Uploads
 Per-attachment size limits by kind (in megabytes) and the per-message attachment cap. An
 absent or partial `Uploads` section keeps the built-in defaults. See
 [Messages & Attachments](messages-and-attachments.md) for how kinds are detected.
 | Key | Default | Description |
 | --- | --- | --- |
 | `Uploads:MaxImageSizeMB` | `10` | Max size for one image attachment |
 | `Uploads:MaxAudioSizeMB` | `10` | Max size for one audio attachment |
 | `Uploads:MaxFileSizeMB` | `100` | Max size for any other attachment |
 | `Uploads:MaxAvatarSizeMB` | `2` | Max avatar upload size |
 | `Uploads:MaxAttachmentsPerMessage` | `10` | Attachments allowed on a single message |
 The server sizes its request-body limits from these values, so raising a limit here is all
 that's needed — no separate Kestrel tuning.
 ### Encryption
 | Key | Default | Description |
@@ -17,7 +17,7 @@ curl -sSfL https://raw.githubusercontent.com/HueByte/EchoHub/master/scripts/inst
 To install a specific version or to a custom directory:
 ```bash
-curl -sSfL .../install.sh | sh -s -- --version 0.2.11
+curl -sSfL .../install.sh | sh -s -- --version 0.2.14
 curl -sSfL .../install.sh | sh -s -- --install-dir /opt/echohub
 ```
@@ -76,11 +76,11 @@ Then connect with any standard IRC client:
 irssi -c localhost -p 6667 -w <password> -n <username>
 ```
-IRC users must have an existing EchoHub account. Authentication works via `PASS`/`NICK`/`USER` or SASL PLAIN. Messages flow bidirectionally between IRC and TUI clients.
+Your nick is your EchoHub username and the server password is your account password (`PASS`/`NICK`/`USER` or SASL PLAIN). Connecting with a new username registers the account. Messages flow bidirectionally between IRC and TUI clients.
 For TLS, set `TlsEnabled: true`, `TlsPort: 6697`, and provide a PKCS#12 certificate path.
-See the [Architecture](architecture.md) page for details on how the IRC gateway integrates with the chat service.
+See the [IRC Gateway guide](irc-gateway.md) for command mapping, attachment rendering, and limitations, or [Architecture](architecture.md) for how the gateway integrates with the chat service.
 ## Configuration
@@ -0,0 +1,103 @@
 # IRC Gateway
 Every EchoHub server can expose a second door: a built-in **IRC gateway** that speaks the
 classic IRC protocol on port 6667. Any standard IRC client — irssi, WeeChat, HexChat,
 Halloy — can join the same channels as TUI users, see the same messages, and chat with the
 same accounts. Under the hood both protocols call the same chat service, so a message sent
 from IRC appears instantly in the TUI and vice versa (see [Architecture](architecture.md)).
 ## Enabling the gateway
 The gateway is off by default. Enable it in `appsettings.json` (or `Irc__Enabled=true` as an
 environment variable):
 ```json
 {
  "Irc": {
    "Enabled": true,
    "Port": 6667,
    "TlsEnabled": false,
    "TlsPort": 6697,
    "TlsCertPath": "",
    "ServerName": "echohub",
    "Motd": "Welcome to EchoHub IRC Gateway!"
  }
 }
 ```
 The plaintext listener always starts on `Port`. The TLS listener on `TlsPort` starts only
 when `TlsEnabled` is `true` **and** `TlsCertPath` points to a PKCS#12 (`.pfx`) certificate.
 See the [configuration reference](configuration.md#irc-gateway) for every option.
 ## Connecting & authentication
 Your IRC **nick is your EchoHub username** and your server password is your **account
 password**. Two flows are supported:
 ```bash
 # classic PASS/NICK/USER — most clients call this the "server password"
 irssi -c chat.example.com -p 6667 -w <password> -n <username>
 ```
 or **SASL PLAIN** (advertised via `CAP LS`), where the SASL username/password are the account
 credentials.
 A few things worth knowing:
 - **Connecting auto-registers.** If the username doesn't exist yet, the gateway creates the
  account with that password (usernames: 3–50 chars of `a-z 0-9 _ -`; passwords: 6+ chars).
  The very first account ever created on a server becomes the **Owner**.
 - Because of that, a typo'd password for an *existing* account fails with
  `Username is already taken` — the gateway tried to log in, couldn't, then tried to register
  the name. If you see that error, re-check your password.
 - Connecting without a password is rejected: `Password required. Use PASS command or SASL PLAIN.`
 ## What maps to what
 | IRC | EchoHub |
 | --- | --- |
 | `JOIN #room` | Join a channel (history is replayed on join) |
 | `JOIN #room <key>` | Join a password-protected (`+k`) channel |
 | `PART` / `QUIT` | Leave channel / disconnect |
 | `LIST` | Public channels only (password-protected ones show a `[+k]` hint) |
 | `TOPIC` | Read or set the channel topic (permission-checked) |
 | `NAMES` / `WHO` | Online users in the channel |
 | `WHOIS` | Profile: display name, channels, idle time, away status |
 | `AWAY [message]` | Sets your EchoHub status to Away / back to Online |
 | `MODE #room +k <key>` / `-k` | Set / clear the channel password |
 Private (unlisted) channels don't appear in `LIST`, but members who know the exact name can
 still `JOIN` them. Channels are not auto-created from IRC — create them from the TUI first.
 ## How messages look
 - **Attachments** arrive as labeled link lines — `[Image: photo.png] https://…`,
  `♪ [Audio: song.mp3] https://…`, `[File: report.pdf] https://…` — and image attachments
  additionally render their **ASCII-art preview** using truecolor ANSI escapes, so a modern
  terminal IRC client shows actual picture previews.
 - **Link embeds** are appended as `│`-prefixed text lines.
 - Long messages are split at word boundaries into IRC-safe lines (~400 bytes each);
  incoming messages may be up to 2,000 characters like any EchoHub message.
 - Your own messages aren't echoed back (standard IRC convention).
 - Moderation actions surface natively: kicks arrive as `KICK`, bans and channel nukes as
  server `NOTICE`s.
 ## Limitations
 The gateway bridges what IRC can express — and deliberately refuses what it can't:
 - **No end-to-end encrypted rooms.** Joining an [encrypted room](encrypted-rooms.md) fails
  with *"Cannot join channel — end-to-end encrypted, use the EchoHub client."* Bridging one
  would require the server to hold the room key, breaking the zero-knowledge design.
 - **No private messages.** `PRIVMSG` to a nick is rejected; EchoHub is channel-based.
 - **Usernames, not display names.** Messages are attributed to the account username;
  a user's display name is visible via `WHOIS`/`WHO` (realname field).
 - **No client features.** Uploading attachments, profiles, themes, and reactions to status
  changes are TUI-client features. Other users' status changes aren't pushed to IRC —
  discover them with `WHOIS`/`WHO`.
 ## How IRC users appear to TUI users
 Users connected *only* through the gateway are tagged `[irc]` in the users panel — a hint
 that they can't receive encrypted content or use client-side features. Someone connected
 with both an IRC client and the TUI shows untagged.
@@ -0,0 +1,109 @@
 # Messages & Attachments
 An EchoHub message is **text content plus up to 10 attachments**, Discord-style. A plain chat
 line is just a message with no attachments; a photo dump is one message with several files and
 an optional caption. This page explains how to attach files, what happens to them on the way to
 the server, and how other clients receive them.
 ## Message basics
 | Limit | Value |
 | --- | --- |
 | Max message length | 2,000 characters |
 | Max newlines per message | 30 (no blank-line runs) |
 | Max attachments per message | 10 |
 | Link embeds per message | first 3 URLs |
 Multiline messages are written with `Ctrl+N` for a newline; `Enter` sends. URLs in a message
 get link embeds (title, description, theme color) fetched by the server.
 ## Attaching files
 All of these end up in the same place — the **staging tray** — and are sent together as one
 message the next time you press `Enter`, with whatever you've typed as the caption:
 - **Paste a copied file** — copy one *or several* files in your file manager and press
  `Ctrl+V` in the input. All of them are staged at once.
 - **Paste an image from the clipboard** — copy an image in a browser (right-click → *Copy
  image*), take a screenshot (`Win+Shift+S`), or copy from an image editor, then `Ctrl+V`.
  The image is attached directly as a PNG named `image.png` — no saving to disk first.
  On Linux this uses `wl-paste` or `xclip`; on macOS it requires
  [`pngpaste`](https://github.com/jcsalterego/pngpaste) (`brew install pngpaste`).
 - **Drag & drop** — drop a file onto the terminal window; the client recognizes the dropped
  path and stages the file.
 - **`/send <filepath>`** — stage a file by path (quote paths containing spaces).
 The input frame's title shows what's currently staged. `/clear` drops all staged attachments
 without sending. Sending with an empty input is fine — the message is just the attachments.
 ```text
 ┌ Message (2 attached: report.pdf, image.png) ──────────────┐
 │ here's the summary and a screenshot_                      │
 └────────────────────────────────────────────────────────────┘
 ```
 **URL sends are different:** `/send <https://…>` sends an image URL immediately as its own
 message — nothing is staged, and it isn't available in end-to-end encrypted rooms (the server
 would have to fetch the image, which would defeat the encryption).
 ## Attachment kinds
 The kind is detected per attachment, not per message:
 | Kind | Detected by | Renders as | Default size limit |
 | --- | --- | --- | --- |
 | **Image** | Magic bytes: JPEG, PNG, GIF, WebP | ASCII-art preview in chat | 10 MB |
 | **Audio** | Extension: `.mp3` `.wav` `.ogg` `.flac` `.aac` `.m4a` `.wma` | Playable row (▶) | 10 MB |
 | **File** | Everything else | Downloadable row | 100 MB |
 Limits are per file and server-configurable — see the `Uploads` section in the
 [configuration guide](configuration.md) (`MaxImageSizeMB`, `MaxAudioSizeMB`, `MaxFileSizeMB`,
 `MaxAttachmentsPerMessage`).
 ## Image previews (ASCII art)
 Images are rendered in chat as half-block ASCII art. You pick the rendering size:
 | Flag | Size | Feel |
 | --- | --- | --- |
 | `-s` / `/size s` | 40 × 40 | compact |
 | `-m` / `/size m` | 80 × 80 | default |
 | `-l` / `/size l` | 120 × 120 | detailed |
 `/size` with no argument opens a picker; the choice persists as your default. A one-off
 `-s|-m|-l` flag on `/send` applies to that message.
 ## Receiving attachments
 Right-click a message (or press `F6` to select one with the arrow keys) for actions:
 - **Images** → save to disk
 - **Audio** → play (in-client playback)
 - **Files** → download
 Downloads go to your configured download folder — set it with `/downloadpath` (no argument
 opens a native folder picker, or pass a path directly).
 ## Attachments in encrypted rooms
 In an [end-to-end encrypted room](encrypted-rooms.md) every attachment is encrypted
 client-side **before** upload:
 ```mermaid
 flowchart LR
    F[File bytes] -->|AES-256-GCM with room key| B[Ciphertext blob]
    F -->|if image: render ASCII locally| A[ASCII preview]
    A -->|room-encrypt| AP["$RC1$… preview"]
    B --> S[Server stores blob + name + size]
    AP --> S
 ```
 The server never sees the file contents or the rendered preview — it stores an opaque blob and
 broadcasts it to members, who decrypt locally. File **names and sizes remain visible** to the
 server so the file list stays usable; don't put secrets in a file name. Pasted clipboard
 images go through exactly the same pipeline.
 ## Deleting messages with attachments
 Deleting a message also removes its uploaded attachment files from the server. You can always
 delete your own messages; moderators can delete others' — see [Moderation & Roles](moderation.md).
@@ -0,0 +1,71 @@
 # Moderation & Roles
 Every EchoHub server has a four-tier role hierarchy. Moderation is **strictly hierarchical**:
 acting on another user requires outranking them — equal rank is never enough — and a few
 invariants protect the server owner from lockouts.
 ## Roles
 | Role | Rank | Users panel glyph | How it's granted |
 | --- | --- | --- | --- |
 | **Owner** | 3 | ★ | The first account ever registered on the server |
 | **Admin** | 2 | ♦ | Assigned by the Owner |
 | **Mod** | 1 | ❀ | Assigned by an Admin or the Owner |
 | **Member** | 0 | — | Everyone else |
 Assign roles with `/role <user> <admin|mod|member>`. Two rules apply:
 - You can only assign roles **strictly below your own** — an Admin can promote to Mod but
  cannot create another Admin; only the Owner can.
 - **Owner is not assignable and not demotable.** There is exactly one Owner (the first
  account), nobody can be promoted to it, and the Owner's role can't be changed.
 ## Actions
 | Command | Minimum role | Effect |
 | --- | --- | --- |
 | `/kick <user> [reason]` | Mod | Disconnects the user. Not persistent — they can reconnect immediately. |
 | `/ban <user> [reason]` | Admin | Persistent: flags the account banned and disconnects it. Banned accounts are rejected at login. |
 | `/unban <user>` | Admin | Lifts a ban. |
 | `/mute <user> [minutes]` | Mod | Blocks the user from sending messages or uploading files. Without a duration the mute is **indefinite**; with one it auto-expires (checked every ~15 seconds). |
 | `/unmute <user>` | Mod | Lifts a mute early. |
 | `/role <user> <role>` | Admin | Assign a role (see rules above). |
 | `/nuke` | Mod | Deletes the **entire history of the current channel**, including all attachment files on disk. Channel-wide — no per-user check. |
 Kick, ban, and mute all enforce the hierarchy: the target's role must be **strictly lower**
 than yours. A Mod cannot kick another Mod; nobody can kick, ban, mute, or demote the Owner.
 ## Deleting messages
 Deletion has its own, slightly different rule set:
 - **Your own messages** — always deletable, whatever your role. Right-click a message →
  *Delete message*, or press `F6`, pick the message, and hit `Delete`.
 - **Someone else's messages** — requires **Mod or higher** *and* strictly outranking the
  author. A Mod can delete a Member's message, but not another Mod's.
 Deleting a message also purges its uploaded attachment blobs from the server's disk, and the
 removal is broadcast live — the message disappears from everyone's chat immediately.
 ## How actions surface
 Everyone in the channel sees moderation happen:
 - **TUI clients** show system messages — *"alice was kicked (reason)"*, *"bob was banned"*,
  *"Channel history has been cleared by a moderator."* The kicked or banned user themselves
  gets a dialog with the reason, then the client disconnects.
 - **IRC clients** get native protocol events: kicks arrive as a real `KICK` command, bans as
  a server `NOTICE`. (See the [IRC Gateway guide](irc-gateway.md).)
 Muted users aren't announced; they simply receive *"You are muted and cannot send messages."*
 when they try to speak.
 ## Design notes
 - All checks run server-side in the moderation API — the client commands are conveniences,
  and the same rules bind IRC users and any direct API caller.
 - Bans are account-level, not IP-level. A banned person can register a fresh account; pair
  bans with registration hygiene on public servers.
 - In [end-to-end encrypted rooms](encrypted-rooms.md) moderation still works at the metadata
  level — messages can be deleted and users muted/kicked by identity — but no moderator can
  *read* the content, including the Owner.
@@ -2,6 +2,14 @@
  items:
    - name: Getting Started
      href: getting-started.md
    - name: TUI Guide
      href: tui-guide.md
    - name: Messages & Attachments
      href: messages-and-attachments.md
    - name: Moderation & Roles
      href: moderation.md
    - name: IRC Gateway
      href: irc-gateway.md
    - name: Docker
      href: docker.md
    - name: Architecture
@@ -0,0 +1,116 @@
 # TUI Guide
 Everything you can do in the EchoHub terminal client: keyboard shortcuts, mouse actions,
 slash commands, themes, and the everyday behaviors (unread markers, auto-join, scrollback)
 that make it feel like a proper IRC-era client with modern comforts.
 ## Layout
 ```text
 ┌ Menu bar ──────────────────────────────────────────────────┐
 │ ┌ Channels ─┐ ┌ Messages ────────────────────┐ ┌ Users ──┐ │
 │ │ #general 3│ │ 12:01 <alice> hi             │ │ ★ alice │ │
 │ │ #dev      │ │ ── new messages ──           │ │ ❀ bob   │ │
 │ │ #random*~ │ │ 12:04 <bob> anyone around?   │ │ carol   │ │
 │ └───────────┘ └──────────────────────────────┘ │ d [irc] │ │
 │ ┌ Message │ Enter=send │ Tab=complete │ … ────┐ └─────────┘ │
 │ │ _                                           │             │
 │ └─────────────────────────────────────────────┘             │
 │ Status: Connected │ v0.2.14 │ alice │ Act: #dev             │
 └─────────────────────────────────────────────────────────────┘
 ```
 Channel list markers: `*` = password-protected, `~` = private (unlisted), plus unread counts
 (orange when you were @mentioned). Users panel glyphs: `★` Owner, `♦` Admin, `❀` Mod,
 `[irc]` for IRC-gateway-only users; status icons `●`/`○`/`◐`/`◌` for online/offline/away/dnd.
 ## Keyboard shortcuts
 ### In the message input
 | Key | Action |
 | --- | --- |
 | `Enter` | Send the message (also sends staged attachments with the text as caption) |
 | `Ctrl+N` | Insert a newline (multiline message) |
 | `Tab` | Autocomplete a slash command (`/th` → `/theme`) |
 | `Ctrl+V` (or `Ctrl+Y`) | Paste — copied files and images become attachments, text pastes normally ([details](messages-and-attachments.md)) |
 | `Ctrl+C` / `Ctrl+X` | Copy / cut in the input |
 | `Ctrl+W` | Delete the word left of the cursor |
 | `Ctrl+K` | Open the search palette |
 | `F6` | Move focus into the message list |
 ### In the message list (after `F6`)
 | Key | Action |
 | --- | --- |
 | `↑` / `↓` | Select a message |
 | `Enter` | Activate: play/download/save an attachment, open an `@mention`'s profile, join a `#channel`, or open the sender's profile |
 | `Delete` / `Backspace` | Delete the selected message (with confirmation; [permission rules](moderation.md)) |
 | `F6` | Return focus to the input |
 ### Anywhere
 | Key | Action |
 | --- | --- |
 | `F2` | Toggle the users panel |
 | `Ctrl+K` | Search palette |
 | `Alt+Q` | Quit |
 ## The search palette (`Ctrl+K`)
 A command-palette that searches **channels and app actions** — type to filter, `↓` to
 navigate, `Enter` to jump. Actions include Connect, Disconnect, Logout, My Profile,
 Set Status, Create/Delete Channel, Saved Servers, Toggle Users Panel, Check for Updates,
 and Quit. `Ctrl+K` again closes it.
 ## Mouse
 - **Right-click a message** for the context menu: save image / play audio / download file
  (depending on the attachment), *Mention @user*, *View profile*, *Copy text*,
  *Copy message ID*, *Delete message*.
 - **Left-click a message** does the most useful thing for that line: attachments
  play/download/save, `@mentions` and the sender open profiles, `#channel` references join
  that channel.
 - **Click a user** in the users panel to open their profile; **click a channel** to switch.
 ## Slash commands
 Type `/help` in any channel for the full list. The highlights:
 | Command | What it does |
 | --- | --- |
 | `/status <online\|away\|dnd\|invisible>` or `/status <message>` | Presence / status message |
 | `/nick <name>`, `/color <#hex>`, `/avatar <url or path>` | Display name, nick color, avatar |
 | `/theme <name>` | Switch theme |
 | `/send`, `/clear`, `/size`, `/downloadpath` | Attachments — see [Messages & Attachments](messages-and-attachments.md) |
 | `/join <channel> [password]`, `/leave`, `/topic <text>` | Channel membership and topic |
 | `/passwd <old> <new>` | Rotate an encrypted room's passphrase |
 | `/profile [user]`, `/users`, `/meta` | Profiles, online users, room info |
 | `/kick`, `/ban`, `/mute`, `/role`, `/nuke`, … | [Moderation](moderation.md) |
 | `/servers`, `/quit` | Saved servers, exit |
 Emoji shortcodes (`:smile:` style) are replaced live as you type.
 ## Themes
 14 built-in themes: **Default, Transparent, TransparentLight, Classic, Light, Hacker,
 Solarized, Dracula, Monokai, Nord, Gruvbox, Ocean, HighContrast, RosePine** — switch from
 the User menu or `/theme <name>`. The two *Transparent* themes use no background color at
 all, so your terminal's own background (and any blur/acrylic) shows through.
 You can add your own: drop a theme JSON into `~/.echohub/themes/` and it appears in the list
 (names that collide with a built-in are skipped).
 ## Everyday behaviors
 - **Unread markers** — a `── new messages ──` rule marks where you left off in each channel,
  irssi-style. Read positions are **persisted per server**, so the marker survives
  reconnects and restarts. The status bar's `Act:` segment lists channels with activity
  (orange when you were @mentioned), and day boundaries draw a date rule.
 - **Auto-join** — connecting joins `#general` plus every channel you're a member of, so
  unread counts and mentions accumulate everywhere. Channels you `/leave` stay left, and
  password-protected or [encrypted rooms](encrypted-rooms.md) are never auto-prompted —
  join those explicitly. `#general` is the home channel and can't be left or deleted.
 - **Scrollback** — history loads 100 messages at a time; scrolling to the top of a channel
  fetches the next page and keeps your position (no jump).
 - **Drag & drop** — dropping a file onto the window stages it as an attachment.
@@ -0,0 +1,20 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>AurionDocs</title>
  <style>
    body { font-family: system-ui, sans-serif; display: grid; place-items: center; min-height: 100vh; margin: 0; background: #1a1a1e; color: #ddd; }
    main { text-align: center; }
    a { color: #7aa2f7; }
  </style>
 </head>
 <body>
  <main>
    <h1>AurionDocs</h1>
    <p>Supplementary documentation for EchoHub.</p>
    <p><a href="../index.html">&larr; Back to EchoHub documentation</a></p>
  </main>
 </body>
 </html>
@@ -4,6 +4,7 @@ Release history for EchoHub.
 ## Releases
 - [v0.2.14](v0.2.14.md) - Clipboard Image & Multi-File Paste, E2E Room Unlock Fixes, Encrypted Key Cache & IRC Gateway Polish
 - [v0.2.13](v0.2.13.md) - Chat Visual Overhaul, Auto-Join All Channels & Persistent Read Positions
 - [v0.2.12](v0.2.12.md) - End-to-End Encrypted Channels, IRC Channel Keys, Image Save & Ctrl+W Crash Fix
 - [v0.2.11](v0.2.11.md) - EchoHubSpace Auth, Live Directory Updates & Server Browser Metadata
@@ -1,5 +1,7 @@
 - name: Overview
  href: index.md
 - name: v0.2.14
  href: v0.2.14.md
 - name: v0.2.13
  href: v0.2.13.md
 - name: v0.2.12
@@ -0,0 +1,22 @@
 # v0.2.14
 A reliability and security pass over end-to-end encrypted rooms: locked channels now offer the passphrase prompt instead of dead-ending on the "rejoin to unlock" placeholder, the client can no longer be tricked into sending plaintext into an encrypted room, and cached room keys are encrypted at rest instead of sitting in the config as base64. Ctrl+V grows up too — images copied from a browser or screenshot tool paste straight into the chat as attachments, and copying several files pastes them all into one message. Plus a set of IRC gateway fixes — decrypted image previews, display-name plumbing, and user/channel indicators.
 ## New Features
 - **Paste images straight from the clipboard** — copy an image from a browser, a screenshot tool (Win+Shift+S), or an image editor and Ctrl+V it into the input: it's attached as a PNG (`image.png`), no saving to disk first, Discord-style. Transparency is preserved when the source provides PNG data; plain clipboard bitmaps are converted automatically. On Linux this uses `wl-paste`/`xclip`; on macOS it requires `pngpaste`. In end-to-end encrypted rooms pasted images go through the same client-side encryption as any other attachment.
 - **Multi-file paste** — copying several files in your file manager and pasting attaches them all to a single message (up to the 10-attachment cap), staged as one batch alongside anything you type as the caption. Previously each pasted file was routed through its own `/send`, which could misbehave on large batches.
 - **Room keys encrypted at rest** — the per-channel room keys cached so you don't retype a passphrase every launch are no longer stored as plain base64 in `config.json`. On Windows they're protected with DPAPI (current-user scope); on Linux/macOS with AES-GCM under a per-user key file created with `0600` permissions next to the config. Existing plain entries migrate to the encrypted format automatically on first load. The passphrase itself is never stored in any form.
 - **`[irc]` tag in the users panel** — users online only through the IRC gateway are tagged `[irc]`, useful context since IRC clients lack encryption, attachments, and profiles. Someone also running the TUI shows untagged.
 - **`~` marker for private channels** — the channel list now marks private (unlisted) channels with a trailing `~`, alongside the existing `*` for password-protected ones (`#room*~` when both apply).
 ## Bug Fixes
 - **Locked encrypted channels now prompt for the passphrase.** Auto-joining your channels at connect silently entered end-to-end encrypted rooms you're a member of without running the unlock flow — on a new device (or after a cancelled prompt) the room showed only `[encrypted — rejoin this channel with its passphrase to unlock]` placeholders, and only a manual `/join` recovered it. Selecting the channel now offers the passphrase prompt; entering it unlocks history and live messages in place. Cancelling is remembered for the session so reselecting the channel doesn't nag — `/join` or trying to send always re-offers the prompt.
 - **A stale cached room key no longer beats a fresh one.** If an encrypted channel was deleted and recreated under the same name, a client that still had the old key cached kept encrypting messages nobody else could read. Typing the passphrase on join now always adopts the key from the server's current envelope, replacing the stale cache.
 - **IRC clients no longer get flooded with ciphertext for image messages.** The gateway forwarded image ASCII previews without stripping transport encryption, spamming IRC clients with one enormous `$ENC$v1$…` line per image. Previews are now decrypted before formatting, and any that still can't be read (e.g. end-to-end room ciphertext the server cannot decrypt) are skipped in favor of the plain `[Image: name] url` line.
 - **Display names now show on chat messages.** Messages only carried the sender's username, so a configured display name appeared in the user list but not on the messages themselves. Live messages, history, and attachment messages now all carry it; mention and profile lookups stay keyed to the username.
 ## Security
 - **No plaintext can leak into an encrypted room.** Previously, a client without the room key silently sent unencrypted text into an end-to-end encrypted channel (and other members saw it as a normal message, none the wiser it went over the wire readable by the server). All send paths — typed messages, staged file attachments, and URL sends — are now blocked while a room is locked: the client offers the unlock prompt, keeps staged files in the tray, and refuses to transmit until the key is present, with a hard guard at the connection layer as backstop.
@@ -46,7 +46,7 @@
    "content": [
      {
        "files": ["**/*.{md,yml}"],
-        "exclude": ["_site/**", "_api_meta/**"]
+        "exclude": ["_site/**", "_api_meta/**", "auriondocs/**"]
      },
      {
        "src": "_api_meta/core",
@@ -75,7 +75,7 @@
    ],
    "resource": [
      {
-        "files": ["images/**"]
+        "files": ["images/**", "auriondocs/**"]
      }
    ],
    "output": "_site",
@@ -11,6 +11,10 @@ Welcome to the EchoHub documentation. EchoHub is a decentralized, IRC-style chat
 ## Quick Links
 - [Getting Started](articles/getting-started.md) - Set up and run EchoHub
 - [TUI Guide](articles/tui-guide.md) - Keyboard shortcuts, slash commands, and everyday usage
 - [Messages & Attachments](articles/messages-and-attachments.md) - Attaching, pasting, and receiving files
 - [Encrypted Rooms](articles/encrypted-rooms.md) - End-to-end encrypted channels
 - [IRC Gateway](articles/irc-gateway.md) - Connect with any IRC client
 - [Architecture](articles/architecture.md) - System design and IRC gateway
 - [API Reference](api/index.md) - Generated C# API documentation
 - [Changelog](changelog/index.md) - Release history
@@ -7,3 +7,5 @@
 - name: API
  href: api/
  homepage: api/index.md
 - name: AurionDocs
  href: auriondocs/index.html
@@ -0,0 +1,12 @@
 {
  "name": "echohub",
  "private": true,
  "description": "Repo tooling — markdown linting. Not an npm package.",
  "scripts": {
    "lint:md": "markdownlint-cli2",
    "lint:md:fix": "markdownlint-cli2 --fix"
  },
  "devDependencies": {
    "markdownlint-cli2": "^0.23.0"
  }
 }
@@ -0,0 +1,61 @@
 # EchoHub - Markdown Lint
 #
 # Runs markdownlint-cli2 over the repo. Rules, globs, and ignores all live in
 # .markdownlint-cli2.jsonc; the linter version is pinned in package.json.
 #
 # Usage:
 #   .\scripts\lint-markdown.ps1            # lint-only, exits non-zero on violations
 #   .\scripts\lint-markdown.ps1 -Fix       # auto-fix what markdownlint can
 #
 # Requires: Node + npx on PATH. Prefers the locally installed linter
 # (`npm install` once); otherwise npx fetches the same pinned version.
 param(
    [switch]$Fix
 )
 $ErrorActionPreference = "Stop"
 if (-not (Get-Command npx -ErrorAction SilentlyContinue)) {
    Write-Host "  ERROR: npx not found on PATH. Install Node.js (https://nodejs.org) and retry." -ForegroundColor Red
    exit 1
 }
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $RootDir   = Split-Path -Parent $ScriptDir
 Push-Location $RootDir
 try {
    # Local install is version-pinned via package.json/package-lock.json; the
    # npx fallback pins the same version so CI and local can never drift.
    if (Test-Path "node_modules/.bin/markdownlint-cli2") {
        $npxArgs = @('--no-install', 'markdownlint-cli2')
    } else {
        $npxArgs = @('--yes', '[email protected]')
    }
    if ($Fix) {
        Write-Host "  Auto-fix mode (--fix): markdownlint will rewrite files in place." -ForegroundColor Yellow
        $npxArgs += '--fix'
    }
    Write-Host "  > npx $($npxArgs -join ' ')" -ForegroundColor Gray
    & npx @npxArgs
    $exit = $LASTEXITCODE
    if ($exit -eq 0) {
        Write-Host "  Markdown lint clean." -ForegroundColor Green
    } elseif ($Fix) {
        Write-Host ""
        Write-Host "  Some issues could not be auto-fixed. Review the output above and fix manually." -ForegroundColor Yellow
    } else {
        Write-Host ""
        Write-Host "  Markdown lint failed. Re-run with -Fix to auto-correct the fixable rules:" -ForegroundColor Red
        Write-Host "    .\scripts\lint-markdown.ps1 -Fix" -ForegroundColor Yellow
    }
    exit $exit
 }
 finally {
    Pop-Location
 }
@@ -2,6 +2,8 @@
 #
 # Lint all Markdown files in the repository.
 # Config, globs, and ignores are defined in .markdownlint-cli2.jsonc.
 # The linter version is pinned in package.json — run `npm install` once,
 # or just use `npm run lint:md` / `npm run lint:md:fix` directly.
 #
 # Usage:
 #   ./scripts/lint-markdown.sh          # check
@@ -12,11 +14,12 @@ set -euo pipefail
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 cd "$REPO_ROOT"
-# Resolve markdownlint-cli2 binary
+# Prefer the locally installed (version-pinned) linter; fall back to a one-off
-if command -v markdownlint-cli2 &>/dev/null; then
+# npx install of the same version pinned in package.json.
-    LINT_CMD="markdownlint-cli2"
+if [ -x "node_modules/.bin/markdownlint-cli2" ]; then
    LINT_CMD="npx --no-install markdownlint-cli2"
 else
-    LINT_CMD="npx --yes markdownlint-cli2"
+    LINT_CMD="npx --yes markdownlint-cli2@0.23.0"
 fi
 echo "Linting Markdown files..."
@@ -1,6 +1,6 @@
 <Project>
  <PropertyGroup>
-    <Version>0.2.13</Version>
+    <Version>0.2.14</Version>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
    <NoWarn>$(NoWarn);CS1591</NoWarn>
  </PropertyGroup>
@@ -35,6 +35,14 @@ public sealed class AppOrchestrator : IDisposable
    private readonly HashSet<string> _channelsLoadingMore = new(StringComparer.OrdinalIgnoreCase);
    private readonly List<string> _stagedAttachments = [];
    // Temp PNGs created for clipboard-image pastes; deleted once their message is sent
    // (or the staging tray is cleared) so pasted screenshots don't pile up in %TEMP%.
    private readonly HashSet<string> _tempPastedFiles = [];
    // E2E channels whose unlock prompt the user cancelled — don't nag on every reselect.
    // Cleared on connect/reconnect; an explicit /join or a send attempt re-offers the prompt.
    private readonly HashSet<string> _declinedUnlocks = new(StringComparer.OrdinalIgnoreCase);
    private ClientConfig _config;
    private readonly UserSession _session = new();
@@ -90,6 +98,8 @@ public sealed class AppOrchestrator : IDisposable
        _mainWindow.OnDisconnectRequested += HandleDisconnect;
        _mainWindow.OnLogoutRequested += HandleLogout;
        _mainWindow.OnMessageSubmitted += HandleMessageSubmitted;
        _mainWindow.OnFilesStaged += HandleFilesStaged;
        _mainWindow.OnImagePasted += HandleImagePasted;
        _mainWindow.OnChannelSelected += HandleChannelSelected;
        _mainWindow.OnProfileRequested += HandleProfileRequested;
        _mainWindow.OnStatusRequested += HandleStatusRequested;
@@ -187,7 +197,8 @@ public sealed class AppOrchestrator : IDisposable
        if (Uri.TryCreate(target, UriKind.Absolute, out var uri)
            && (uri.Scheme == "http" || uri.Scheme == "https"))
        {
-            if (_conn.RoomKeys.HasKey(channel))
+            // Also blocks locked E2E channels (no cached key) — a URL send would be plaintext
            if (_conn.RoomKeys.HasKey(channel) || _conn.RoomKeys.IsChannelEncrypted(channel))
            {
                InvokeUI(() => _mainWindow.ShowError(
                    "Sending by URL isn't available in encrypted channels — download the file and /send it instead."));
@@ -216,11 +227,89 @@ public sealed class AppOrchestrator : IDisposable
    private Task HandleCmdClearAttachments()
    {
        var temps = _stagedAttachments.Where(_tempPastedFiles.Contains).ToList();
        _tempPastedFiles.ExceptWith(temps);
        CleanupPastedTempFiles(temps);
        _stagedAttachments.Clear();
        InvokeUI(RefreshStagingTray);
        return Task.CompletedTask;
    }
    /// <summary>
    /// Stages a batch of local files (multi-file paste or drag-and-drop) as attachments of the
    /// next message. Runs synchronously on the UI thread — unlike routing each file through a
    /// fire-and-forget /send command, a 10-file paste can't race the staging list.
    /// </summary>
    private void HandleFilesStaged(string channel, IReadOnlyList<string> files)
    {
        if (!_conn.IsAuthenticated || !_conn.IsConnected)
            return;
        var slotsLeft = HubConstants.MaxAttachmentsPerMessage - _stagedAttachments.Count;
        _stagedAttachments.AddRange(files.Take(Math.Max(0, slotsLeft)));
        if (files.Count > slotsLeft)
            _mainWindow.ShowError($"You can attach at most {HubConstants.MaxAttachmentsPerMessage} files per message.");
        RefreshStagingTray();
    }
    /// <summary>
    /// Stages an image pasted as raw clipboard data (copied from a browser, a screenshot tool,
    /// or an image editor). The PNG is written to a per-paste temp folder so it flows through
    /// the same path-based staging/encryption pipeline as regular files, and the temp file is
    /// deleted once the message is sent.
    /// </summary>
    private void HandleImagePasted(string channel, byte[] png)
    {
        if (!_conn.IsAuthenticated || !_conn.IsConnected)
            return;
        if (_stagedAttachments.Count >= HubConstants.MaxAttachmentsPerMessage)
        {
            _mainWindow.ShowError($"You can attach at most {HubConstants.MaxAttachmentsPerMessage} files per message.");
            return;
        }
        try
        {
            // A unique folder per paste keeps the Discord-style "image.png" display name
            // while letting several pasted images coexist in one message.
            var dir = Path.Combine(Path.GetTempPath(), "EchoHub", "pasted", Guid.NewGuid().ToString("N")[..8]);
            Directory.CreateDirectory(dir);
            var path = Path.Combine(dir, "image.png");
            File.WriteAllBytes(path, png);
            _tempPastedFiles.Add(path);
            _stagedAttachments.Add(path);
            RefreshStagingTray();
        }
        catch (Exception ex)
        {
            Log.Error(ex, "Staging a pasted clipboard image failed");
            _mainWindow.ShowError($"Pasting image failed: {ex.Message}");
        }
    }
    /// <summary>Best-effort removal of pasted-image temp files and their per-paste folders.</summary>
    private static void CleanupPastedTempFiles(IReadOnlyList<string> files)
    {
        foreach (var file in files)
        {
            try
            {
                File.Delete(file);
                if (Path.GetDirectoryName(file) is { } dir)
                    Directory.Delete(dir);
            }
            catch (Exception ex)
            {
                Log.Debug(ex, "Could not delete pasted-image temp file {File}", file);
            }
        }
    }
    /// <summary>
    /// Opens the ASCII-art size picker (no argument) or sets it directly from "s"/"m"/"l" (or
    /// small/medium/large). The choice is a persistent preference applied to attached images.
@@ -290,15 +379,27 @@ public sealed class AppOrchestrator : IDisposable
    /// </summary>
    private void SendStagedMessage(string channel, string content)
    {
        var staged = _stagedAttachments.ToList();
        _stagedAttachments.Clear();
        InvokeUI(RefreshStagingTray);
        var hasRoomKey = _conn.RoomKeys.TryGetKey(channel, out var roomKey);
        var size = _config.DefaultAsciiSize;
        RunAsync(async () =>
        {
            // Locked E2E channel: block the send and keep the files staged for after the unlock
            if (!await EnsureRoomUnlockedForSendAsync(channel))
                return;
            var staged = _stagedAttachments.ToList();
            _stagedAttachments.Clear();
            InvokeUI(RefreshStagingTray);
            // Pasted clipboard images live in temp files; once this send owns them they are
            // deleted whether the upload succeeds or fails (the tray is already cleared).
            var tempFiles = staged.Where(_tempPastedFiles.Contains).ToList();
            _tempPastedFiles.ExceptWith(tempFiles);
            try
            {
                var hasRoomKey = _conn.RoomKeys.TryGetKey(channel, out var roomKey);
                var outgoing = new List<OutgoingAttachment>();
                foreach (var path in staged)
                    outgoing.Add(await BuildOutgoingAttachmentAsync(path, hasRoomKey ? roomKey : null, size));
@@ -308,6 +409,11 @@ public sealed class AppOrchestrator : IDisposable
                    : content;
                await _conn.Api!.SendMessageWithAttachmentsAsync(channel, wireContent, outgoing, size);
            }
            finally
            {
                CleanupPastedTempFiles(tempFiles);
            }
        }, "Send failed");
    }
@@ -417,6 +523,8 @@ public sealed class AppOrchestrator : IDisposable
        try
        {
            crypto = await _conn.Api!.GetChannelCryptoAsync(channelName);
            if (crypto is not null)
                _conn.RoomKeys.MarkChannelEncrypted(channelName, crypto.IsEncrypted);
        }
        catch (Exception ex)
        {
@@ -438,15 +546,19 @@ public sealed class AppOrchestrator : IDisposable
            {
                var outcome = await _conn.JoinChannelAsync(channelName, wirePassword);
-                if (outcome.WrappedRoomKey is not null && !_conn.RoomKeys.HasKey(channelName))
+                if (outcome.WrappedRoomKey is not null)
                {
-                    if (kek is not null && RoomCrypto.TryUnwrapRoomKey(outcome.WrappedRoomKey, kek, out var roomKey))
+                    // A typed passphrase always wins over the cache: unwrap the fresh envelope
                    // and overwrite any stale key (e.g. the channel was deleted and recreated
                    // under the same name — the old key would encrypt for nobody).
                    if (kek is not null && _conn.RoomKeys.TryStoreFromEnvelope(channelName, outcome.WrappedRoomKey, kek))
                    {
-                        _conn.RoomKeys.StoreKey(channelName, roomKey);
+                        lock (_declinedUnlocks) _declinedUnlocks.Remove(channelName);
                        // Re-fetch so history decrypts with the now-available room key
                        return await _conn.GetHistoryAsync(channelName);
                    }
                    if (!_conn.RoomKeys.HasKey(channelName))
                        return await UnlockRoomKeyAsync(channelName, outcome);
                }
@@ -484,12 +596,17 @@ public sealed class AppOrchestrator : IDisposable
            var passphrase = await prompt.Task;
            if (passphrase is null)
-                return outcome.History; // stays locked; placeholders render instead of content
+            {
                // Stays locked; placeholders render instead of content. Remember the decline
                // so reselecting the channel doesn't nag every time.
                lock (_declinedUnlocks) _declinedUnlocks.Add(channelName);
                return outcome.History;
            }
            var derived = RoomCrypto.DeriveKeys(passphrase, salt);
-            if (RoomCrypto.TryUnwrapRoomKey(outcome.WrappedRoomKey, derived.KeyEncryptionKey, out var roomKey))
+            if (_conn.RoomKeys.TryStoreFromEnvelope(channelName, outcome.WrappedRoomKey, derived.KeyEncryptionKey))
            {
-                _conn.RoomKeys.StoreKey(channelName, roomKey);
+                lock (_declinedUnlocks) _declinedUnlocks.Remove(channelName);
                return await _conn.GetHistoryAsync(channelName);
            }
@@ -497,6 +614,66 @@ public sealed class AppOrchestrator : IDisposable
        }
    }
    /// <summary>
    /// True when a channel is end-to-end encrypted, its room key isn't cached, and the
    /// user hasn't already declined the unlock prompt this session.
    /// </summary>
    private bool NeedsUnlockPrompt(string channelName)
    {
        if (!_conn.RoomKeys.IsChannelEncrypted(channelName) || _conn.RoomKeys.HasKey(channelName))
            return false;
        lock (_declinedUnlocks) return !_declinedUnlocks.Contains(channelName);
    }
    /// <summary>
    /// Unlock flow for a channel that is already hub-joined (auto-join/reconnect discard
    /// the key envelope): rejoin — members pass the gate without a password and the join
    /// result carries the envelope — then run the passphrase prompt. On success the
    /// decrypted history replaces the locked placeholders. Returns true when unlocked.
    /// </summary>
    private async Task<bool> UnlockTrackedChannelAsync(string channelName)
    {
        try
        {
            var outcome = await _conn.JoinChannelAsync(channelName, null);
            if (outcome.WrappedRoomKey is null)
                return false; // not an E2E channel after all
            var history = await UnlockRoomKeyAsync(channelName, outcome);
            if (!_conn.RoomKeys.HasKey(channelName))
                return false; // cancelled or never unwrapped
            if (history is not null)
                InvokeUI(() => _messageManager.LoadHistory(channelName, history));
            return true;
        }
        catch (Exception ex)
        {
            Log.Warning(ex, "Unlock flow failed for #{Channel}", channelName);
            return false;
        }
    }
    /// <summary>
    /// Send guard for end-to-end encrypted channels: without the cached room key nothing
    /// may leave the client (it would be plaintext in a room others read as encrypted).
    /// Offers the unlock prompt right away — even after an earlier decline, since the user
    /// is actively trying to talk here. Returns true when sending is safe.
    /// </summary>
    private async Task<bool> EnsureRoomUnlockedForSendAsync(string channelName)
    {
        if (!_conn.RoomKeys.IsChannelEncrypted(channelName) || _conn.RoomKeys.HasKey(channelName))
            return true;
        if (await UnlockTrackedChannelAsync(channelName))
            return true;
        InvokeUI(() => _mainWindow.ShowError(
            $"#{channelName} is end-to-end encrypted and locked — nothing was sent. Enter its passphrase to unlock it first."));
        return false;
    }
    /// <summary>
    /// Changes the current encrypted channel's passphrase: re-derives the join credential
    /// and re-wraps the cached room content key under the new passphrase. History is
@@ -922,6 +1099,7 @@ public sealed class AppOrchestrator : IDisposable
        _conn.Reconnected += () =>
        {
            lock (_channelUsersLock) _channelUsers.Clear();
            lock (_declinedUnlocks) _declinedUnlocks.Clear();
            RunAsync(
                async () => await _conn.RejoinChannelsAsync(),
                "Failed to rejoin channels after reconnect");
@@ -970,6 +1148,7 @@ public sealed class AppOrchestrator : IDisposable
            }
            _session.Username = result.Login.Username;
            lock (_declinedUnlocks) _declinedUnlocks.Clear();
            // Persisted last-read markers for this server — used to seed unread counts,
            // mention highlights, and "new messages" markers from the fetched histories.
@@ -1073,9 +1252,12 @@ public sealed class AppOrchestrator : IDisposable
            return;
        }
-        RunAsync(
+        RunAsync(async () =>
-            async () => await _conn.SendMessageAsync(channelName, content),
+        {
-            "Send failed");
+            if (!await EnsureRoomUnlockedForSendAsync(channelName))
                return;
            await _conn.SendMessageAsync(channelName, content);
        }, "Send failed");
    }
    private void HandleDeleteMessageRequested(Guid messageId)
@@ -1112,6 +1294,12 @@ public sealed class AppOrchestrator : IDisposable
                UpdateServerConfig(server =>
                    server.LeftChannels.RemoveAll(c => c.Equals(channelName, StringComparison.OrdinalIgnoreCase)));
            }
            else if (NeedsUnlockPrompt(channelName))
            {
                // Auto-join/reconnect already hub-joined this E2E channel but discarded the
                // key envelope — selecting it is the user's cue to unlock it.
                await UnlockTrackedChannelAsync(channelName);
            }
            try
            {
@@ -38,7 +38,8 @@ public class SavedServer
    /// <summary>
    /// Cached room content keys for end-to-end encrypted channels on this server,
-    /// keyed by channel name (base64). Like RefreshToken, these live only on the
+    /// keyed by channel name and encrypted at rest (see RoomKeyProtector; legacy
    /// entries were plain base64). Like RefreshToken, these live only on the
    /// user's machine — the server never sees them.
    /// </summary>
    public Dictionary<string, string> ChannelKeys { get; set; } = [];
@@ -9,6 +9,9 @@ public static class ConfigManager
    private static readonly string ConfigPath = Path.Combine(ConfigDir, "config.json");
    /// <summary>Directory holding the client config and local key material.</summary>
    public static string ConfigDirectory => ConfigDir;
    // Load-mutate-save cycles run from both the UI thread and background tasks
    // (token refresh, room keys, last-read checkpoints) — serialize file access.
    private static readonly Lock FileLock = new();
@@ -12,6 +12,7 @@
    <PackageReference Include="Serilog" Version="4.3.1" />
    <PackageReference Include="Serilog.Settings.Configuration" Version="10.0.0" />
    <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
    <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="10.0.3" />
    <PackageReference Include="Terminal.Gui" Version="2.0.0-develop.5043" />
  </ItemGroup>
@@ -0,0 +1,257 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
 using Serilog;
 using SixLabors.ImageSharp;
 namespace EchoHub.Client.Services;
 /// <summary>
 /// Reads raw image data from the OS clipboard (e.g. an image copied from a browser, or a
 /// Win+Shift+S screenshot), which terminals cannot paste as text. Always returns PNG bytes:
 /// clipboard PNG data is passed through, clipboard bitmaps (CF_DIB) are re-encoded.
 /// </summary>
 public static class ClipboardImage
 {
    private static readonly byte[] PngMagic = [0x89, 0x50, 0x4E, 0x47];
    public static bool TryGetPng(out byte[] png)
    {
        png = [];
        try
        {
            if (OperatingSystem.IsWindows())
                return TryGetWindows(out png);
            if (OperatingSystem.IsLinux())
                return TryGetLinux(out png);
            if (OperatingSystem.IsMacOS())
                return TryGetMacOS(out png);
        }
        catch (Exception ex)
        {
            Log.Warning(ex, "Reading an image from the clipboard failed");
        }
        return false;
    }
    private static bool IsPng(byte[] data) =>
        data.Length > PngMagic.Length && data.AsSpan(0, PngMagic.Length).SequenceEqual(PngMagic);
    /// <summary>
    /// Converts clipboard DIB bytes (a BITMAPINFOHEADER/V4/V5 + optional palette/masks + pixel
    /// data, i.e. a .bmp file without its 14-byte file header) to PNG. Returns null when the
    /// data is malformed or not decodable as a bitmap.
    /// </summary>
    public static byte[]? DibToPng(byte[] dib)
    {
        if (dib.Length < 40)
            return null;
        var headerSize = BitConverter.ToInt32(dib, 0);
        if (headerSize < 40 || headerSize > dib.Length)
            return null;
        var bitCount = BitConverter.ToUInt16(dib, 14);
        var compression = BitConverter.ToUInt32(dib, 16);
        var clrUsed = BitConverter.ToUInt32(dib, 32);
        // Pixel data offset: file header + info header + color masks + palette.
        // BI_BITFIELDS masks follow a plain 40-byte header; larger headers embed them.
        var maskBytes = headerSize == 40 && compression == 3 ? 12
                      : headerSize == 40 && compression == 6 ? 16
                      : 0;
        var paletteEntries = clrUsed != 0 ? clrUsed
                           : bitCount <= 8 ? 1u << bitCount
                           : 0u;
        var pixelOffset = (uint)(14 + headerSize + maskBytes) + paletteEntries * 4;
        var bmp = new byte[14 + dib.Length];
        bmp[0] = (byte)'B';
        bmp[1] = (byte)'M';
        BitConverter.TryWriteBytes(bmp.AsSpan(2), (uint)bmp.Length);
        BitConverter.TryWriteBytes(bmp.AsSpan(10), pixelOffset);
        dib.CopyTo(bmp, 14);
        try
        {
            using var image = Image.Load(bmp);
            using var ms = new MemoryStream();
            image.SaveAsPng(ms);
            return ms.ToArray();
        }
        catch (Exception ex) when (ex is ImageFormatException or InvalidOperationException)
        {
            Log.Warning(ex, "Clipboard DIB could not be decoded as a bitmap");
            return null;
        }
    }
    // ── Windows: "PNG" / "image/png" registered formats, then CF_DIB ─────────
    private const uint CfDib = 8;
    [SupportedOSPlatform("windows")]
    private static bool TryGetWindows(out byte[] png)
    {
        png = [];
        // Browsers register a "PNG" (Chromium) or "image/png" (some apps) clipboard format
        // preserving transparency; CF_DIB is synthesized by Windows for everything else
        // (screenshots, image editors), so together these cover all image sources.
        var pngFormat = RegisterClipboardFormatW("PNG");
        var mimeFormat = RegisterClipboardFormatW("image/png");
        var hasAny = (pngFormat != 0 && IsClipboardFormatAvailable(pngFormat))
                  || (mimeFormat != 0 && IsClipboardFormatAvailable(mimeFormat))
                  || IsClipboardFormatAvailable(CfDib);
        if (!hasAny)
            return false;
        var opened = false;
        for (var attempt = 0; attempt < 5 && !opened; attempt++)
            opened = OpenClipboard(IntPtr.Zero);
        if (!opened)
            return false;
        try
        {
            foreach (var format in new[] { pngFormat, mimeFormat })
            {
                if (format == 0 || !IsClipboardFormatAvailable(format))
                    continue;
                var data = ReadHGlobal(GetClipboardData(format));
                if (data is not null && IsPng(data))
                {
                    png = data;
                    return true;
                }
            }
            if (IsClipboardFormatAvailable(CfDib)
                && ReadHGlobal(GetClipboardData(CfDib)) is { } dib
                && DibToPng(dib) is { } converted)
            {
                png = converted;
                return true;
            }
            return false;
        }
        finally
        {
            CloseClipboard();
        }
    }
    [SupportedOSPlatform("windows")]
    private static byte[]? ReadHGlobal(IntPtr handle)
    {
        if (handle == IntPtr.Zero)
            return null;
        var ptr = GlobalLock(handle);
        if (ptr == IntPtr.Zero)
            return null;
        try
        {
            var size = (int)GlobalSize(handle);
            if (size <= 0)
                return null;
            var data = new byte[size];
            Marshal.Copy(ptr, data, 0, size);
            return data;
        }
        finally
        {
            GlobalUnlock(handle);
        }
    }
    [DllImport("user32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool OpenClipboard(IntPtr hWndNewOwner);
    [DllImport("user32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool CloseClipboard();
    [DllImport("user32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool IsClipboardFormatAvailable(uint format);
    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr GetClipboardData(uint uFormat);
    [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    private static extern uint RegisterClipboardFormatW(string lpszFormat);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr GlobalLock(IntPtr hMem);
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool GlobalUnlock(IntPtr hMem);
    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern nuint GlobalSize(IntPtr hMem);
    // ── Linux: image/png via wl-paste or xclip ────────────────────────────────
    [SupportedOSPlatform("linux")]
    private static bool TryGetLinux(out byte[] png)
    {
        png = [];
        var data = RunForBytes("wl-paste", ["--type", "image/png"])
                ?? RunForBytes("xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]);
        if (data is null || !IsPng(data))
            return false;
        png = data;
        return true;
    }
    // ── macOS: pngpaste (brew install pngpaste), when present ────────────────
    [SupportedOSPlatform("macos")]
    private static bool TryGetMacOS(out byte[] png)
    {
        png = [];
        var data = RunForBytes("pngpaste", ["-"]);
        if (data is null || !IsPng(data))
            return false;
        png = data;
        return true;
    }
    private static byte[]? RunForBytes(string fileName, IEnumerable<string> args)
    {
        var psi = new ProcessStartInfo(fileName)
        {
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            CreateNoWindow = true,
        };
        foreach (var arg in args)
            psi.ArgumentList.Add(arg);
        try
        {
            using var process = Process.Start(psi);
            if (process is null)
                return null;
            using var ms = new MemoryStream();
            process.StandardOutput.BaseStream.CopyTo(ms);
            process.WaitForExit(2000);
            return process.ExitCode == 0 && ms.Length > 0 ? ms.ToArray() : null;
        }
        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or FileNotFoundException)
        {
            return null; // tool not installed
        }
    }
 }
@@ -112,6 +112,11 @@ internal sealed class ConnectionManager : IAsyncDisposable
            var channels = await _apiClient.GetChannelsAsync();
            // Known E2E channels — senders consult this so a client without the room
            // key never emits plaintext into an encrypted room
            foreach (var channel in channels)
                _roomKeys.MarkChannelEncrypted(channel.Name, channel.IsEncrypted);
            // Join default channel + fetch history
            onStatus("Joining channels...");
            _joinedChannels.Clear();
@@ -296,7 +301,11 @@ internal sealed class ConnectionManager : IAsyncDisposable
        connection.OnForceDisconnect += reason => ForceDisconnected?.Invoke(reason);
        connection.OnMessageDeleted += (ch, id) => MessageDeleted?.Invoke(ch, id);
        connection.OnChannelNuked += ch => ChannelNuked?.Invoke(ch);
-        connection.OnChannelUpdated += ch => ChannelUpdated?.Invoke(ch);
+        connection.OnChannelUpdated += ch =>
        {
            _roomKeys.MarkChannelEncrypted(ch.Name, ch.IsEncrypted);
            ChannelUpdated?.Invoke(ch);
        };
        connection.OnError += msg => Error?.Invoke(msg);
        connection.OnConnectionStateChanged += status => ConnectionStatusChanged?.Invoke(status);
        connection.OnReconnected += () => Reconnected?.Invoke();
@@ -26,6 +26,21 @@ public sealed class ChannelPasswordRequiredException : Exception
    }
 }
 /// <summary>
 /// Thrown when sending into an end-to-end encrypted channel whose room key isn't cached:
 /// without the key the message would leave the client as plaintext, which must never happen.
 /// </summary>
 public sealed class RoomLockedException : Exception
 {
    public string ChannelName { get; }
    public RoomLockedException(string channelName)
        : base($"#{channelName} is end-to-end encrypted and locked — enter its passphrase to unlock it before sending.")
    {
        ChannelName = channelName;
    }
 }
 public sealed class EchoHubConnection : IAsyncDisposable
 {
    public const string LockedMessagePlaceholder =
@@ -167,6 +182,8 @@ public sealed class EchoHubConnection : IAsyncDisposable
                throw new ChannelPasswordRequiredException(channelName, result.Error ?? "Channel is password protected.");
            throw new InvalidOperationException(result.Error ?? "Failed to join channel.");
        }
        if (result.WrappedRoomKey is not null)
            _roomKeys.MarkChannelEncrypted(channelName, true);
        return new JoinOutcome(DecryptMessages(result.History), result.EncryptionSalt, result.WrappedRoomKey);
    }
@@ -180,6 +197,8 @@ public sealed class EchoHubConnection : IAsyncDisposable
        // Room layer first (end-to-end, server can't read), then transport encryption
        if (_roomKeys.TryGetKey(channelName, out var roomKey))
            content = RoomCrypto.EncryptText(content, roomKey);
        else if (_roomKeys.IsChannelEncrypted(channelName))
            throw new RoomLockedException(channelName); // never fall through to plaintext
        var encrypted = _encryption.Encrypt(content);
        await _connection.InvokeAsync("SendMessage", channelName, encrypted);
@@ -0,0 +1,120 @@
 using System.Security.Cryptography;
 using EchoHub.Core.Security;
 using Serilog;
 namespace EchoHub.Client.Services;
 /// <summary>
 /// Encrypts cached room content keys at rest so the client config never holds them as
 /// plain base64. Windows uses DPAPI (current-user scope, format prefix "dp1:"). On other
 /// platforms the keys are AES-GCM encrypted with a per-user master key file stored next
 /// to the config with 0600 permissions (prefix "k1:") — without an OS keychain that is
 /// file-permission-level protection, not zero-knowledge: anyone who can read both the
 /// config and the key file can recover the room keys. Values with no recognized prefix
 /// are legacy plain-base64 keys from older clients; they load once and are re-encrypted.
 /// The room passphrase itself is never stored in any form.
 /// </summary>
 public sealed class RoomKeyProtector
 {
    public const string DpapiPrefix = "dp1:";
    public const string KeyFilePrefix = "k1:";
    private const string KeyFileName = "roomkeys.key";
    private const int MasterKeySizeBytes = 32;
    private const int RoomKeySizeBytes = 32;
    private readonly string _keyFilePath;
    private readonly bool _useDpapi;
    private readonly Lock _lock = new();
    private byte[]? _masterKey;
    /// <param name="keyDirectory">Directory holding the master key file (the client config dir).</param>
    /// <param name="useDpapi">Overrides the platform default (DPAPI on Windows) — for tests.</param>
    public RoomKeyProtector(string keyDirectory, bool? useDpapi = null)
    {
        _keyFilePath = Path.Combine(keyDirectory, KeyFileName);
        _useDpapi = useDpapi ?? OperatingSystem.IsWindows();
    }
    /// <summary>Encrypts a room key for storage in the config file.</summary>
    public string Protect(byte[] roomKey)
    {
        if (_useDpapi && OperatingSystem.IsWindows())
            return DpapiPrefix + Convert.ToBase64String(
                ProtectedData.Protect(roomKey, null, DataProtectionScope.CurrentUser));
        return KeyFilePrefix + Convert.ToBase64String(RoomCrypto.EncryptBytes(roomKey, GetMasterKey()));
    }
    /// <summary>
    /// Decrypts a stored value back into a room key. <paramref name="wasLegacy"/> is true when
    /// the value was an unencrypted legacy entry that should be re-persisted via
    /// <see cref="Protect"/>. Returns false for unreadable values (wrong user/machine, missing
    /// or regenerated key file, malformed data) — the caller drops the entry and the user can
    /// recover it by re-entering the passphrase.
    /// </summary>
    public bool TryUnprotect(string stored, out byte[] roomKey, out bool wasLegacy)
    {
        roomKey = [];
        wasLegacy = false;
        try
        {
            if (stored.StartsWith(DpapiPrefix, StringComparison.Ordinal))
            {
                if (!OperatingSystem.IsWindows())
                    return false; // config copied from a Windows machine
                roomKey = ProtectedData.Unprotect(
                    Convert.FromBase64String(stored[DpapiPrefix.Length..]), null, DataProtectionScope.CurrentUser);
                return roomKey.Length > 0;
            }
            if (stored.StartsWith(KeyFilePrefix, StringComparison.Ordinal))
            {
                if (!File.Exists(_keyFilePath))
                    return false;
                roomKey = RoomCrypto.DecryptBytes(
                    Convert.FromBase64String(stored[KeyFilePrefix.Length..]), GetMasterKey());
                return roomKey.Length > 0;
            }
            // No recognized prefix — legacy plain-base64 room key from a pre-encryption client
            roomKey = Convert.FromBase64String(stored);
            wasLegacy = true;
            return roomKey.Length == RoomKeySizeBytes;
        }
        catch (Exception ex) when (ex is FormatException or CryptographicException
            or IOException or UnauthorizedAccessException)
        {
            return false;
        }
    }
    private byte[] GetMasterKey()
    {
        lock (_lock)
        {
            if (_masterKey is not null)
                return _masterKey;
            if (File.Exists(_keyFilePath))
            {
                var existing = File.ReadAllBytes(_keyFilePath);
                if (existing.Length == MasterKeySizeBytes)
                    return _masterKey = existing;
                Log.Warning("Room-key master key file has unexpected size — regenerating (previously cached keys become unreadable)");
            }
            var key = RandomNumberGenerator.GetBytes(MasterKeySizeBytes);
            Directory.CreateDirectory(Path.GetDirectoryName(_keyFilePath)!);
            File.WriteAllBytes(_keyFilePath, key);
            if (!OperatingSystem.IsWindows())
                File.SetUnixFileMode(_keyFilePath, UnixFileMode.UserRead | UnixFileMode.UserWrite);
            return _masterKey = key;
        }
    }
 }
@@ -1,4 +1,5 @@
 using EchoHub.Client.Config;
 using EchoHub.Core.Security;
 using Serilog;
 namespace EchoHub.Client.Services;
@@ -6,14 +7,28 @@ namespace EchoHub.Client.Services;
 /// <summary>
 /// Holds room content keys for end-to-end encrypted channels: in-memory for the
 /// active session, persisted per-server in the client config (like saved sessions)
-/// so users don't retype the passphrase every launch. Keys never leave this machine.
+/// so users don't retype the passphrase every launch. Keys never leave this machine
 /// and are encrypted at rest by <see cref="RoomKeyProtector"/>. Also tracks which
 /// channels are known to be end-to-end encrypted, so senders can refuse to emit
 /// plaintext into a room whose key isn't cached yet.
 /// </summary>
 public sealed class RoomKeyStore
 {
    private readonly Dictionary<string, byte[]> _keys = new(StringComparer.OrdinalIgnoreCase);
    private readonly HashSet<string> _encryptedChannels = new(StringComparer.OrdinalIgnoreCase);
    private readonly RoomKeyProtector _protector;
    private readonly Lock _lock = new();
    private string? _serverUrl;
    public RoomKeyStore() : this(new RoomKeyProtector(ConfigManager.ConfigDirectory))
    {
    }
    public RoomKeyStore(RoomKeyProtector protector)
    {
        _protector = protector;
    }
    /// <summary>Binds the store to a server and loads that server's cached keys from config.</summary>
    public void LoadForServer(string serverUrl)
    {
@@ -21,21 +36,34 @@ public sealed class RoomKeyStore
        {
            _serverUrl = serverUrl;
            _keys.Clear();
            _encryptedChannels.Clear();
            var server = FindServer(ConfigManager.Load(), serverUrl);
            if (server is null) return;
-            foreach (var (channel, base64) in server.ChannelKeys)
+            var legacyFound = false;
            foreach (var (channel, stored) in server.ChannelKeys)
            {
-                try
+                if (_protector.TryUnprotect(stored, out var key, out var wasLegacy))
                {
-                    _keys[channel] = Convert.FromBase64String(base64);
+                    _keys[channel] = key;
                    legacyFound |= wasLegacy;
                }
-                catch (FormatException)
+                else
                {
-                    Log.Warning("Ignoring malformed cached room key for #{Channel}", channel);
+                    Log.Warning("Ignoring unreadable cached room key for #{Channel}", channel);
                }
            }
            // One-way upgrade: legacy plain-base64 entries get re-persisted encrypted
            // (unreadable entries drop out — the unlock prompt recovers those rooms).
            if (legacyFound)
                Persist(s =>
                {
                    s.ChannelKeys.Clear();
                    foreach (var (channel, key) in _keys)
                        s.ChannelKeys[channel] = _protector.Protect(key);
                });
        }
    }
@@ -62,10 +90,26 @@ public sealed class RoomKeyStore
        lock (_lock)
        {
            _keys[channelName] = key;
-            Persist(server => server.ChannelKeys[channelName] = Convert.ToBase64String(key));
+            _encryptedChannels.Add(channelName);
            Persist(server => server.ChannelKeys[channelName] = _protector.Protect(key));
        }
    }
    /// <summary>
    /// Unwraps a fresh key envelope and caches the key, overwriting any stale cached key
    /// (e.g. the channel was deleted and recreated under the same name, so the old key
    /// would encrypt messages nobody else can read). Returns false when the KEK doesn't
    /// open the envelope — the cache is left untouched.
    /// </summary>
    public bool TryStoreFromEnvelope(string channelName, string wrappedRoomKey, byte[] kek)
    {
        if (!RoomCrypto.TryUnwrapRoomKey(wrappedRoomKey, kek, out var roomKey))
            return false;
        StoreKey(channelName, roomKey);
        return true;
    }
    public void RemoveKey(string channelName)
    {
        lock (_lock)
@@ -75,11 +119,36 @@ public sealed class RoomKeyStore
        }
    }
    /// <summary>
    /// Records whether a channel is end-to-end encrypted (from channel listings, crypto
    /// metadata, or join outcomes). Senders consult this to block plaintext into rooms
    /// whose key isn't cached.
    /// </summary>
    public void MarkChannelEncrypted(string channelName, bool isEncrypted)
    {
        lock (_lock)
        {
            if (isEncrypted)
                _encryptedChannels.Add(channelName);
            else
                _encryptedChannels.Remove(channelName);
        }
    }
    public bool IsChannelEncrypted(string channelName)
    {
        lock (_lock)
        {
            return _encryptedChannels.Contains(channelName);
        }
    }
    public void Clear()
    {
        lock (_lock)
        {
            _keys.Clear();
            _encryptedChannels.Clear();
            _serverUrl = null;
        }
    }
@@ -381,6 +381,9 @@ public sealed class ChatMessageManager
    private List<ChatLine> FormatMessage(MessageDto message)
    {
        var time = FormatTime(message.SentAt);
        // Show the display name, but keep color + click identity keyed to the username
        // so they stay consistent with the user list and profile lookups.
        var senderName = message.SenderDisplayName ?? message.SenderUsername;
        var senderColor = HexColorHelper.ParseHexColor(message.SenderNicknameColor)
            ?? NickColorHelper.GetAttribute(message.SenderUsername);
@@ -394,7 +397,7 @@ public sealed class ChatMessageManager
            var displayContent = EmojiHelper.ReplaceEmoji(message.Content);
            var contentLines = displayContent.Split('\n');
-            var header = HeaderSegments(time, message.SenderUsername, senderColor);
+            var header = HeaderSegments(time, senderName, senderColor);
            header.AddRange(ChatColors.SplitMentions(contentLines[0].TrimEnd('\r')));
            lines.Add(new ChatLine(header));
@@ -413,7 +416,7 @@ public sealed class ChatMessageManager
                1 => $"[{attachments[0].Kind.ToString().ToLowerInvariant()}]",
                _ => $"[{attachments.Count} attachments]",
            };
-            var header = HeaderSegments(time, message.SenderUsername, senderColor);
+            var header = HeaderSegments(time, senderName, senderColor);
            header.Add(new(summary, null));
            lines.Add(new ChatLine(header));
        }
@@ -18,6 +18,7 @@ public class ChannelListSource : IListDataSource
    private readonly Dictionary<string, int> _unreadCounts = [];
    private readonly HashSet<string> _protectedChannels = [];
    private readonly HashSet<string> _mentionChannels = [];
    private readonly HashSet<string> _privateChannels = [];
    private string _activeChannel = string.Empty;
    public event NotifyCollectionChangedEventHandler? CollectionChanged;
@@ -32,7 +33,8 @@ public class ChannelListSource : IListDataSource
    private static readonly Attribute MentionAttr = new(new Color(230, 140, 60), Color.None);
    public void Update(List<string> channels, Dictionary<string, int> unread, string activeChannel,
-        IReadOnlySet<string>? protectedChannels = null, IReadOnlySet<string>? mentionChannels = null)
+        IReadOnlySet<string>? protectedChannels = null, IReadOnlySet<string>? mentionChannels = null,
        IReadOnlySet<string>? privateChannels = null)
    {
        _channelNames.Clear();
        _channelNames.AddRange(channels);
@@ -45,6 +47,9 @@ public class ChannelListSource : IListDataSource
        _mentionChannels.Clear();
        if (mentionChannels is not null)
            _mentionChannels.UnionWith(mentionChannels);
        _privateChannels.Clear();
        if (privateChannels is not null)
            _privateChannels.UnionWith(privateChannels);
        _activeChannel = activeChannel;
        MaxItemLength = channels.Count > 0 ? channels.Max(c => c.Length + 6) : 0;
        if (!SuspendCollectionChangedEvent)
@@ -67,8 +72,12 @@ public class ChannelListSource : IListDataSource
        var normalAttr = listView.GetAttributeForRole(VisualRole.Normal);
        var focusAttr = listView.GetAttributeForRole(VisualRole.Focus);
        var prefix = isActive ? "> " : "  ";
-        // Trailing * marks password-protected (+k) channels
+        // Trailing * marks password-protected (+k) channels; ~ marks private (unlisted) ones
-        var channelText = _protectedChannels.Contains(name) ? $"#{name}*" : $"#{name}";
+        var channelText = $"#{name}";
        if (_protectedChannels.Contains(name))
            channelText += "*";
        if (_privateChannels.Contains(name))
            channelText += "~";
        var badge = hasUnread ? $" ({unread})" : "";
        // Resolve Transparent backgrounds to the view's actual background
@@ -11,6 +11,7 @@ using Serilog;
 using Terminal.Gui.App;
 using Terminal.Gui.Configuration;
 using Terminal.Gui.Drawing;
 using Terminal.Gui.Drivers;
 using Terminal.Gui.Input;
 using Terminal.Gui.Text;
 using Terminal.Gui.ViewBase;
@@ -41,23 +42,24 @@ public sealed partial class MainWindow : Runnable
    private bool _usersPanelVisible = true;
    private const int UsersPanelWidth = 22;
    private const string DefaultInputTitle = "Message │ Enter=send │ Tab=complete │ Ctrl+K=search │ F6=pick message";
-    private static readonly Key F2Key = Key.F2;
+    private const KeyCode F2Key = KeyCode.F2;
    private bool _hasStagedAttachments;
    internal static readonly string AppVersion =
        typeof(MainWindow).Assembly.GetName().Version?.ToString(3) ?? "?";
-    // Cached Key constants — compare via .KeyCode to avoid Key.Equals (which also checks Handled)
+    // Key bindings as KeyCode constants: comparing raw KeyCodes avoids Key.Equals (which also
-    private static readonly Key EnterKey = Key.Enter;
+    // checks Handled), and constants make them usable as switch case labels.
-    private static readonly Key NewlineKey = Key.N.WithCtrl;
+    private const KeyCode EnterKey = KeyCode.Enter;
-    private static readonly Key AltQKey = Key.Q.WithAlt;
+    private const KeyCode NewlineKey = KeyCode.N | KeyCode.CtrlMask;
-    private static readonly Key TabKey = Key.Tab;
+    private const KeyCode AltQKey = KeyCode.Q | KeyCode.AltMask;
-    private static readonly Key CtrlKKey = Key.K.WithCtrl;
+    private const KeyCode TabKey = KeyCode.Tab;
-    private static readonly Key CtrlVKey = Key.V.WithCtrl;
+    private const KeyCode CtrlKKey = KeyCode.K | KeyCode.CtrlMask;
-    private static readonly Key CtrlXKey = Key.X.WithCtrl;
+    private const KeyCode CtrlVKey = KeyCode.V | KeyCode.CtrlMask;
-    private static readonly Key CtrlCKey = Key.C.WithCtrl;
+    private const KeyCode CtrlXKey = KeyCode.X | KeyCode.CtrlMask;
-    private static readonly Key CtrlYKey = Key.Y.WithCtrl;
+    private const KeyCode CtrlCKey = KeyCode.C | KeyCode.CtrlMask;
-    private static readonly Key F6Key = Key.F6;
+    private const KeyCode CtrlYKey = KeyCode.Y | KeyCode.CtrlMask;
    private const KeyCode F6Key = KeyCode.F6;
    // Available slash commands for Tab autocomplete
    private static readonly string[] SlashCommands =
@@ -87,6 +89,18 @@ public sealed partial class MainWindow : Runnable
    /// </summary>
    public event Action<string, string>? OnMessageSubmitted;
    /// <summary>
    /// Fired when local files arrive via paste or drag-and-drop to be staged as attachments.
    /// Parameters: channel name, absolute paths of existing files.
    /// </summary>
    public event Action<string, IReadOnlyList<string>>? OnFilesStaged;
    /// <summary>
    /// Fired when raw image data is pasted from the clipboard (e.g. copied from a browser or a
    /// screenshot tool). Parameters: channel name, PNG-encoded image bytes.
    /// </summary>
    public event Action<string, byte[]>? OnImagePasted;
    /// <summary>
    /// Fired when the user requests to connect via the menu.
    /// </summary>
@@ -557,7 +571,7 @@ public sealed partial class MainWindow : Runnable
    private void OnMessageListKeyDown(object? sender, Key e)
    {
        // F6 returns focus to the input box.
-        if (e.KeyCode == F6Key.KeyCode)
+        if (e.KeyCode == F6Key)
        {
            _inputField.SetFocus();
            e.Handled = true;
@@ -703,18 +717,17 @@ public sealed partial class MainWindow : Runnable
    private void OnInputKeyDown(object? sender, Key e)
    {
-        if (e.KeyCode == TabKey.KeyCode)
+        switch (e.KeyCode)
        {
            case TabKey:
                TryAutocompleteCommand();
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == NewlineKey.KeyCode)
+            case NewlineKey:
        {
                _inputField.InsertText("\n");
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == EnterKey.KeyCode)
+            case EnterKey:
        {
                var text = _inputField.Text?.Trim() ?? string.Empty;
                // Send when there's text, or when only attachments are staged (empty caption).
                if ((!string.IsNullOrEmpty(text) || _hasStagedAttachments)
@@ -723,46 +736,50 @@ public sealed partial class MainWindow : Runnable
                    OnMessageSubmitted?.Invoke(_messageManager.CurrentChannel, text);
                    _inputField.Text = string.Empty;
                }
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == AltQKey.KeyCode)
+            case AltQKey:
        {
                _app.RequestStop();
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == CtrlKKey.KeyCode)
+            case CtrlKKey:
        {
                ShowSearchDialog();
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == F6Key.KeyCode)
+            case F6Key:
        {
                // Move focus into the message list so you can select a message (arrows) and
                // delete it (Delete). F6 again returns focus here. (Esc is the app quit key.)
                FocusMessageList();
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == CtrlVKey.KeyCode || e.KeyCode == CtrlYKey.KeyCode)
+            case CtrlVKey:
-        {
+            case CtrlYKey:
-            // If a file was copied in the OS file manager, the clipboard holds a file list
+                // Discord-style paste priority. Copied files in the OS file manager put a file
-            // (not text) — attach it. Otherwise paste text. This is the reliable path on
+                // list (not text) on the clipboard — attach them all. Copied image data (browser
-            // Windows Terminal, which never pastes copied files as text.
+                // right-click copy, screenshot tools) is attached as a PNG. Otherwise paste text.
                // Terminals never deliver either of the first two as text, so this is the only path.
                if (ClipboardFiles.TryGetFiles(out var pastedFiles))
                    StageFiles(pastedFiles);
                else if (!string.IsNullOrEmpty(_messageManager.CurrentChannel)
                         && ClipboardImage.TryGetPng(out var pastedPng))
                    OnImagePasted?.Invoke(_messageManager.CurrentChannel, pastedPng);
                else
                    GuardedClipboardAction(() => _inputField.Paste(), "paste");
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == CtrlXKey.KeyCode)
+            case CtrlXKey:
        {
                GuardedClipboardAction(() => _inputField.Cut(), "cut");
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == CtrlCKey.KeyCode)
+            case CtrlCKey:
        {
                GuardedClipboardAction(() => _inputField.Copy(), "copy");
-            e.Handled = true;
+                break;
            default:
                return; // not one of ours — leave e.Handled false so the key types normally
        }
        e.Handled = true;
    }
    /// <summary>
@@ -872,17 +889,16 @@ public sealed partial class MainWindow : Runnable
    }
    /// <summary>
-    /// Routes files (from a drop or a file-clipboard paste) through the /send pipeline, which
+    /// Stages files (from a drop or a file-clipboard paste) as attachments in one batch; the
-    /// stages them; the next Enter sends them with any typed caption.
+    /// next Enter sends them with any typed caption.
    /// </summary>
-    private void StageFiles(IEnumerable<string> files)
+    private void StageFiles(IReadOnlyList<string> files)
    {
        var channel = _messageManager.CurrentChannel;
        if (string.IsNullOrEmpty(channel))
            return;
-        foreach (var file in files)
+        OnFilesStaged?.Invoke(channel, files);
            OnMessageSubmitted?.Invoke(channel, $"/send \"{file}\"");
    }
    private void OnChatViewportChanged()
@@ -898,21 +914,25 @@ public sealed partial class MainWindow : Runnable
    private void OnWindowKeyDown(object? sender, Key e)
    {
-        if (e.KeyCode == AltQKey.KeyCode)
+        switch (e.KeyCode)
        {
            case AltQKey:
                _app.RequestStop();
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == F2Key.KeyCode)
+            case F2Key:
        {
                ToggleUsersPanel();
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == CtrlKKey.KeyCode)
+            case CtrlKKey:
        {
                ShowSearchDialog();
-            e.Handled = true;
+                break;
            default:
                return;
        }
        e.Handled = true;
    }
    private void ShowSearchDialog()
@@ -1317,8 +1337,11 @@ public sealed partial class MainWindow : Runnable
    /// </summary>
    private void RefreshChannelList()
    {
        var privateChannels = _channelNames
            .Where(n => _channelPublic.TryGetValue(n, out var isPublic) && !isPublic)
            .ToHashSet();
        _channelListSource.Update(_channelNames, _messageManager.GetUnreadCounts(), _messageManager.CurrentChannel,
-            _channelProtected, _messageManager.MentionChannels);
+            _channelProtected, _messageManager.MentionChannels, privateChannels);
        _channelList.Source = _channelListSource;
        // Restore selection to current channel
@@ -1394,6 +1417,10 @@ public sealed partial class MainWindow : Runnable
            var text = roleTag.Length > 0
                ? $"{statusIcon} {roleTag} {name}"
                : $"{statusIcon} {name}";
            // Users connected only via the IRC gateway get a tag — they lack client features
            // (encryption, attachments, profiles), which is useful context in conversation.
            if (u.IsIrc)
                text += " [irc]";
            // Fall back to the deterministic per-nick palette so user-list colors
            // match the same user's messages in chat.
            var nameColor = HexColorHelper.ParseHexColor(u.NicknameColor)
@@ -4,6 +4,12 @@ public static class HubConstants
 {
    public const string ChatHubPath = "/hubs/chat";
    public const string DefaultChannel = "general";
    /// <summary>
    /// Connection-id prefix for IRC gateway connections. The presence tracker uses it to
    /// tell IRC-only users apart from native (SignalR) clients.
    /// </summary>
    public const string IrcConnectionIdPrefix = "irc-";
    public const int DefaultHistoryCount = 100;
    public const int MaxMessageLength = 2000;
    public const int MaxImageSizeBytes = 10 * 1024 * 1024; // 10 MB
@@ -10,7 +10,8 @@ public record MessageDto(
    string ChannelName,
    DateTimeOffset SentAt,
    List<AttachmentDto>? Attachments = null,
-    List<EmbedDto>? Embeds = null);
+    List<EmbedDto>? Embeds = null,
    string? SenderDisplayName = null);
 /// <summary>
 /// A file attached to a message. <see cref="AsciiPreview"/> holds the color-tag art for
@@ -30,6 +30,7 @@ public record UserPresenceDto(
    string? NicknameColor,
    UserStatus Status,
    string? StatusMessage,
-    ServerRole Role);
+    ServerRole Role,
    bool IsIrc = false);
 public record AvatarUploadResponse(string AvatarAscii);
@@ -1,5 +1,6 @@
 using System.Net.Sockets;
 using System.Text;
 using EchoHub.Core.Constants;
 namespace EchoHub.Server.Irc;
@@ -14,7 +15,7 @@ public sealed class IrcClientConnection : IAsyncDisposable
    private readonly SemaphoreSlim _writeLock = new(1, 1);
    // Connection identity
-    public string ConnectionId { get; } = $"irc-{Guid.NewGuid()}";
+    public string ConnectionId { get; } = $"{HubConstants.IrcConnectionIdPrefix}{Guid.NewGuid()}";
    // Registration state
    public string? Nickname { get; set; }
@@ -308,7 +308,8 @@ public class ChannelsController : ControllerBase
            sender?.NicknameColor,
            channelName,
            message.SentAt,
-            attachmentDtos);
+            attachmentDtos,
            SenderDisplayName: sender?.DisplayName);
        await _chatService.BroadcastMessageAsync(channelName, messageDto);
@@ -444,7 +445,8 @@ public class ChannelsController : ControllerBase
            sender?.NicknameColor,
            channelName,
            message.SentAt,
-            [new AttachmentDto(AttachmentKind.Image, attachmentUrl, fileName, imageBytes.Length, _encryption.Encrypt(preview))]);
+            [new AttachmentDto(AttachmentKind.Image, attachmentUrl, fileName, imageBytes.Length, _encryption.Encrypt(preview))],
            SenderDisplayName: sender?.DisplayName);
        await _chatService.BroadcastMessageAsync(channelName, messageDto);
@@ -121,7 +121,8 @@ public class ChatService : IChatService
                {
                    presence = new UserPresenceDto(
                        user.Username, user.DisplayName, user.NicknameColor,
-                        user.Status, user.StatusMessage, user.Role);
+                        user.Status, user.StatusMessage, user.Role,
                        _presenceTracker.IsIrcOnly(user.Username));
                }
            }
            catch (Exception ex)
@@ -236,7 +237,8 @@ public class ChatService : IChatService
            sender?.NicknameColor,
            channelName,
            message.SentAt,
-            Embeds: embeds);
+            Embeds: embeds,
            SenderDisplayName: sender?.DisplayName);
        await BroadcastToAllAsync(b => b.SendMessageToChannelAsync(channelName, messageDto));
@@ -279,7 +281,8 @@ public class ChatService : IChatService
            user.NicknameColor,
            status,
            statusMessage,
-            user.Role);
+            user.Role,
            _presenceTracker.IsIrcOnly(user.Username));
        var channels = _presenceTracker.GetChannelsForUser(username);
        await BroadcastToAllAsync(b => b.SendUserStatusChangedAsync(channels, presence));
@@ -295,16 +298,20 @@ public class ChatService : IChatService
        using var scope = _scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
-        return await db.Users
+        var users = await db.Users
            .Where(u => onlineUsernames.Contains(u.Username) && u.Status != UserStatus.Invisible)
-            .Select(u => new UserPresenceDto(
+            .ToListAsync();
        // IsIrcOnly comes from the in-memory tracker, so map outside the EF query
        return users.Select(u => new UserPresenceDto(
                u.Username,
                u.DisplayName,
                u.NicknameColor,
                u.Status,
                u.StatusMessage,
-                u.Role))
+                u.Role,
-            .ToListAsync();
+                _presenceTracker.IsIrcOnly(u.Username)))
            .ToList();
    }
    public Task BroadcastMessageAsync(string channelName, MessageDto message)
@@ -380,7 +387,7 @@ public class ChatService : IChatService
            .Join(db.Users,
                m => m.SenderUserId,
                u => u.Id,
-                (m, u) => new { m, u.NicknameColor })
+                (m, u) => new { m, u.NicknameColor, u.DisplayName })
            .ToListAsync();
        raw.Reverse();
@@ -448,7 +455,8 @@ public class ChatService : IChatService
                channelName,
                x.m.SentAt,
                attachments,
-                embeds));
+                embeds,
                x.DisplayName));
        }
        // Lazily delete the pruned messages (+ their attachment rows) as they're encountered.
@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
 using EchoHub.Core.Constants;
 namespace EchoHub.Server.Services;
@@ -174,6 +175,20 @@ public class PresenceTracker
        return _userConnections.TryGetValue(username, out var connections) && connections.Count > 0;
    }
    /// <summary>
    /// True when the user is online exclusively through the IRC gateway. A user who also has a
    /// native client connected has full features, so they don't count as IRC-only.
    /// </summary>
    public bool IsIrcOnly(string username)
    {
        lock (_lock)
        {
            return _userConnections.TryGetValue(username, out var connections)
                && connections.Count > 0
                && connections.All(c => c.StartsWith(HubConstants.IrcConnectionIdPrefix, StringComparison.Ordinal));
        }
    }
    public int GetOnlineUserCount()
    {
        return _userConnections.Count;
@@ -0,0 +1,78 @@
 using EchoHub.Client.Services;
 using EchoHub.Core.Services;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.PixelFormats;
 using Xunit;
 namespace EchoHub.Tests;
 public class ClipboardImageTests
 {
    /// <summary>
    /// Encodes an image as BMP and strips the 14-byte BITMAPFILEHEADER, producing exactly what
    /// the Windows clipboard hands out as CF_DIB.
    /// </summary>
    private static byte[] MakeDib(Image<Rgba32> image, BmpBitsPerPixel bpp)
    {
        using var ms = new MemoryStream();
        image.Save(ms, new BmpEncoder { BitsPerPixel = bpp });
        return ms.ToArray()[14..];
    }
    private static Image<Rgba32> MakeTestImage()
    {
        var image = new Image<Rgba32>(4, 3);
        image[0, 0] = new Rgba32(255, 0, 0);
        image[3, 2] = new Rgba32(0, 0, 255);
        return image;
    }
    [Theory]
    [InlineData(BmpBitsPerPixel.Pixel24)]
    [InlineData(BmpBitsPerPixel.Pixel32)]
    [InlineData(BmpBitsPerPixel.Pixel8)] // palette-based: exercises the palette offset math
    public void DibToPng_ConvertsDibToValidPng(BmpBitsPerPixel bpp)
    {
        using var original = MakeTestImage();
        var dib = MakeDib(original, bpp);
        var png = ClipboardImage.DibToPng(dib);
        Assert.NotNull(png);
        using var pngStream = new MemoryStream(png);
        Assert.True(FileValidationHelper.IsValidImage(pngStream));
        using var decoded = Image.Load<Rgba32>(png);
        Assert.Equal(original.Width, decoded.Width);
        Assert.Equal(original.Height, decoded.Height);
    }
    [Fact]
    public void DibToPng_PreservesPixels_For24Bpp()
    {
        using var original = MakeTestImage();
        var dib = MakeDib(original, BmpBitsPerPixel.Pixel24);
        var png = ClipboardImage.DibToPng(dib);
        Assert.NotNull(png);
        using var decoded = Image.Load<Rgba32>(png);
        Assert.Equal(new Rgba32(255, 0, 0), decoded[0, 0]);
        Assert.Equal(new Rgba32(0, 0, 255), decoded[3, 2]);
    }
    [Fact]
    public void DibToPng_ReturnsNull_ForTruncatedData()
    {
        Assert.Null(ClipboardImage.DibToPng([0x28, 0x00, 0x00]));
    }
    [Fact]
    public void DibToPng_ReturnsNull_ForGarbageData()
    {
        var garbage = new byte[256];
        new Random(42).NextBytes(garbage);
        Assert.Null(ClipboardImage.DibToPng(garbage));
    }
 }
@@ -1,3 +1,4 @@
 using EchoHub.Core.Constants;
 using EchoHub.Server.Services;
 using Xunit;
@@ -65,4 +66,48 @@ public class PresenceTrackerTests
        Assert.Contains("general", channels);
        Assert.Contains("random", channels);
    }
    [Fact]
    public void IsIrcOnly_AllConnectionsIrc_ReturnsTrue()
    {
        var tracker = new PresenceTracker();
        tracker.UserConnected($"{HubConstants.IrcConnectionIdPrefix}conn1", Guid.NewGuid(), "alice");
        Assert.True(tracker.IsIrcOnly("alice"));
    }
    [Fact]
    public void IsIrcOnly_NativeConnection_ReturnsFalse()
    {
        var tracker = new PresenceTracker();
        tracker.UserConnected("conn1", Guid.NewGuid(), "alice");
        Assert.False(tracker.IsIrcOnly("alice"));
    }
    [Fact]
    public void IsIrcOnly_MixedConnections_ReturnsFalse()
    {
        var tracker = new PresenceTracker();
        var userId = Guid.NewGuid();
        tracker.UserConnected($"{HubConstants.IrcConnectionIdPrefix}conn1", userId, "alice");
        tracker.UserConnected("conn2", userId, "alice");
        Assert.False(tracker.IsIrcOnly("alice"));
    }
    [Fact]
    public void IsIrcOnly_OfflineUser_ReturnsFalse()
    {
        var tracker = new PresenceTracker();
        Assert.False(tracker.IsIrcOnly("nobody"));
    }
    [Fact]
    public void IsIrcOnly_NativeConnectionDisconnects_BecomesTrue()
    {
        var tracker = new PresenceTracker();
        var userId = Guid.NewGuid();
        tracker.UserConnected($"{HubConstants.IrcConnectionIdPrefix}conn1", userId, "alice");
        tracker.UserConnected("conn2", userId, "alice");
        tracker.UserDisconnected("conn2");
        Assert.True(tracker.IsIrcOnly("alice"));
    }
 }
@@ -0,0 +1,168 @@
 using System.Security.Cryptography;
 using EchoHub.Client.Services;
 using EchoHub.Core.Security;
 using Xunit;
 namespace EchoHub.Tests;
 /// <summary>
 /// At-rest encryption of the cached room keys (RoomKeyProtector) and the store-level
 /// decisions built on it (RoomKeyStore): fresh envelopes overwrite stale cached keys,
 /// legacy plain-base64 entries are recognized for the one-way migration.
 /// </summary>
 public class RoomKeyProtectorTests : IDisposable
 {
    private readonly string _dir = Directory.CreateTempSubdirectory("echohub-keyprotector-").FullName;
    public void Dispose()
    {
        try { Directory.Delete(_dir, recursive: true); } catch { /* best-effort cleanup */ }
    }
    [Fact]
    public void KeyFile_Protect_RoundTrips()
    {
        var protector = new RoomKeyProtector(_dir, useDpapi: false);
        var key = RoomCrypto.GenerateRoomKey();
        var stored = protector.Protect(key);
        Assert.StartsWith(RoomKeyProtector.KeyFilePrefix, stored);
        Assert.True(protector.TryUnprotect(stored, out var recovered, out var wasLegacy));
        Assert.Equal(key, recovered);
        Assert.False(wasLegacy);
    }
    [Fact]
    public void Dpapi_Protect_RoundTrips()
    {
        if (!OperatingSystem.IsWindows()) return; // DPAPI is Windows-only
        var protector = new RoomKeyProtector(_dir, useDpapi: true);
        var key = RoomCrypto.GenerateRoomKey();
        var stored = protector.Protect(key);
        Assert.StartsWith(RoomKeyProtector.DpapiPrefix, stored);
        Assert.True(protector.TryUnprotect(stored, out var recovered, out var wasLegacy));
        Assert.Equal(key, recovered);
        Assert.False(wasLegacy);
    }
    [Fact]
    public void Protect_DoesNotStoreThePlainKey()
    {
        var protector = new RoomKeyProtector(_dir, useDpapi: false);
        var key = RoomCrypto.GenerateRoomKey();
        var stored = protector.Protect(key);
        Assert.DoesNotContain(Convert.ToBase64String(key), stored);
    }
    [Fact]
    public void Legacy_PlainBase64_IsAccepted_AndFlaggedForMigration()
    {
        var protector = new RoomKeyProtector(_dir, useDpapi: false);
        var key = RoomCrypto.GenerateRoomKey();
        Assert.True(protector.TryUnprotect(Convert.ToBase64String(key), out var recovered, out var wasLegacy));
        Assert.Equal(key, recovered);
        Assert.True(wasLegacy);
        // The migration re-protects it; the upgraded value round-trips and is no longer legacy
        var upgraded = protector.Protect(recovered);
        Assert.True(protector.TryUnprotect(upgraded, out var recoveredAgain, out var stillLegacy));
        Assert.Equal(key, recoveredAgain);
        Assert.False(stillLegacy);
    }
    [Fact]
    public void Malformed_Values_AreRejected()
    {
        var protector = new RoomKeyProtector(_dir, useDpapi: false);
        Assert.False(protector.TryUnprotect("not base64 at all!!", out _, out _));
        Assert.False(protector.TryUnprotect(RoomKeyProtector.KeyFilePrefix + "not base64!!", out _, out _));
        // Valid base64 but not a 32-byte room key → not a usable legacy entry
        Assert.False(protector.TryUnprotect(Convert.ToBase64String([1, 2, 3]), out _, out _));
    }
    [Fact]
    public void KeyFile_Lost_MakesStoredValuesUnreadable_NotThrow()
    {
        var protector = new RoomKeyProtector(_dir, useDpapi: false);
        var stored = protector.Protect(RoomCrypto.GenerateRoomKey());
        File.Delete(Path.Combine(_dir, "roomkeys.key"));
        // A fresh protector regenerates a different master key — the value must fail
        // cleanly (entry dropped, passphrase prompt recovers it), not throw
        var fresh = new RoomKeyProtector(_dir, useDpapi: false);
        Assert.False(fresh.TryUnprotect(stored, out _, out _));
    }
 }
 public class RoomKeyStoreEnvelopeTests
 {
    // Note: without LoadForServer the store never touches the config file on disk —
    // these tests exercise the in-memory decision logic only.
    private static RoomKeyStore NewStore() =>
        new(new RoomKeyProtector(Path.Combine(Path.GetTempPath(), "echohub-unused"), useDpapi: false));
    [Fact]
    public void TryStoreFromEnvelope_FreshEnvelope_OverwritesStaleCachedKey()
    {
        var store = NewStore();
        var stale = RoomCrypto.GenerateRoomKey();
        store.StoreKey("vault", stale);
        // Channel deleted and recreated under the same name → new room key, new envelope
        var fresh = RoomCrypto.GenerateRoomKey();
        var kek = RandomNumberGenerator.GetBytes(32);
        var wrapped = RoomCrypto.WrapRoomKey(fresh, kek);
        Assert.True(store.TryStoreFromEnvelope("vault", wrapped, kek));
        Assert.True(store.TryGetKey("vault", out var current));
        Assert.Equal(fresh, current);
    }
    [Fact]
    public void TryStoreFromEnvelope_WrongKek_KeepsCachedKey()
    {
        var store = NewStore();
        var cached = RoomCrypto.GenerateRoomKey();
        store.StoreKey("vault", cached);
        var wrapped = RoomCrypto.WrapRoomKey(RoomCrypto.GenerateRoomKey(), RandomNumberGenerator.GetBytes(32));
        Assert.False(store.TryStoreFromEnvelope("vault", wrapped, RandomNumberGenerator.GetBytes(32)));
        Assert.True(store.TryGetKey("vault", out var current));
        Assert.Equal(cached, current);
    }
    [Fact]
    public void MarkChannelEncrypted_TracksAndUntracks()
    {
        var store = NewStore();
        Assert.False(store.IsChannelEncrypted("vault"));
        store.MarkChannelEncrypted("vault", true);
        Assert.True(store.IsChannelEncrypted("vault"));
        Assert.True(store.IsChannelEncrypted("VAULT")); // channel names are case-insensitive
        store.MarkChannelEncrypted("vault", false);
        Assert.False(store.IsChannelEncrypted("vault"));
    }
    [Fact]
    public void StoreKey_MarksChannelEncrypted()
    {
        var store = NewStore();
        store.StoreKey("vault", RoomCrypto.GenerateRoomKey());
        Assert.True(store.IsChannelEncrypted("vault"));
    }
 }