@maincode-ai/matilda-code 0.21.12 → 0.21.13-nightly.20261027.e00306cd3

package/bundled/mainy/docs/features/markdown-rendering.md

@@ -1,183 +0,0 @@
-# Markdown Rendering
-
-Matilda Code renders common Markdown structures directly in the TUI so model
-answers are easier to scan without leaving the terminal. The renderer is
-designed to keep the original source reachable, especially for visual blocks
-such as Mermaid diagrams and LaTeX math.
-
-## Render and Raw Modes
-
-By default, Markdown is shown in `render` mode. Supported blocks render as
-visual previews where possible:
-
-- Mermaid fenced code blocks
-- Markdown tables
-- task lists
-- blockquotes
-- inline and block LaTeX math
-- fenced code blocks with syntax highlighting
-
-Press `Alt/Option+M` to toggle the current session between modes. On macOS,
-the terminal must send Option as Meta for this shortcut; otherwise Option+M is
-treated as normal text input.
-
-- `render`: show rich terminal previews for supported Markdown.
-- `raw`: show source-oriented Markdown for visual blocks such as Mermaid,
-  tables, and LaTeX.
-
-To start Matilda Code in raw mode by default, set `ui.renderMode`:
-
-```json
-{
-  "ui": {
-    "renderMode": "raw"
-  }
-}
-```
-
-Accepted values are `"render"` and `"raw"`. The shortcut only changes the
-current session view; it does not rewrite your settings file.
-
-## Mermaid
-
-Fenced `mermaid` code blocks render visually in `render` mode. The TUI uses a
-layered strategy:
-
-1. If enabled and supported, Matilda Code asks Mermaid CLI (`mmdc`) to render the
-   diagram to a PNG and sends it to the terminal image protocol.
-2. If terminal images are unavailable but `chafa` is installed, the same PNG can
-   be converted to ANSI block graphics.
-3. Otherwise, Matilda Code falls back to a terminal wireframe or compact text
-   preview.
-4. If a Mermaid diagram type cannot be previewed, Matilda Code shows the original
-   fenced source instead of hiding it behind a placeholder.
-
-Mermaid image rendering is disabled by default because it requires external
-renderers and terminal image support. Enable it with:
-
-```bash
-MATILDA_CODE_MERMAID_IMAGE_RENDERING=1 matilda
-```
-
-Optional environment variables:
-
-| Variable                                       | Description                                                                            |
-| ---------------------------------------------- | -------------------------------------------------------------------------------------- |
-| `MATILDA_CODE_MERMAID_IMAGE_RENDERING=1`       | Enables external Mermaid image rendering.                                              |
-| `MATILDA_CODE_DISABLE_MERMAID_IMAGES=1`        | Disables Mermaid image rendering even when enabled elsewhere.                          |
-| `MATILDA_CODE_MERMAID_IMAGE_PROTOCOL=kitty`    | Forces Kitty protocol output. Useful for terminals such as Kitty and Ghostty.          |
-| `MATILDA_CODE_MERMAID_IMAGE_PROTOCOL=iterm2`   | Requests iTerm2 inline images. Interactive TUI rendering falls back to text/ANSI.      |
-| `MATILDA_CODE_MERMAID_IMAGE_PROTOCOL=off`      | Disables terminal image protocols and allows text or `chafa` fallback.                 |
-| `MATILDA_CODE_MERMAID_MMD_CLI=/path/to/mmdc`   | Uses a specific Mermaid CLI executable.                                                |
-| `MATILDA_CODE_MERMAID_ALLOW_NPX=1`             | Allows Matilda Code to run `npx @mermaid-js/mermaid-cli` when `mmdc` is not installed. |
-| `MATILDA_CODE_MERMAID_ALLOW_LOCAL_RENDERERS=1` | Allows project-local renderer binaries under `node_modules/.bin`.                      |
-| `MATILDA_CODE_MERMAID_RENDER_WIDTH=1200`       | Overrides the PNG render width.                                                        |
-| `MATILDA_CODE_MERMAID_RENDER_TIMEOUT_MS=10000` | Overrides the external render timeout, capped at 60000 ms.                             |
-| `MATILDA_CODE_MERMAID_CELL_ASPECT_RATIO=0.5`   | Adjusts image row fitting for terminal font cell geometry.                             |
-
-The first image render can be slow, especially when `npx` needs to resolve or
-download Mermaid CLI. During streaming, Matilda Code shows a bounded text preview
-and attempts image rendering only after the model response is complete.
-
-### Mermaid Source Copy
-
-Every rendered Mermaid block includes a source hint such as:
-
-```text
-Mermaid flowchart (TD) · source: /copy mermaid 1
-```
-
-Use these commands to copy Mermaid source from the last AI response:
-
-| Command                | Behavior                                      |
-| ---------------------- | --------------------------------------------- |
-| `/copy mermaid`        | Copies the last Mermaid block.                |
-| `/copy mermaid 1`      | Copies the first Mermaid block.               |
-| `/copy code mermaid`   | Copies the last fenced `mermaid` code block.  |
-| `/copy code mermaid 1` | Copies the first fenced `mermaid` code block. |
-
-`/copy code 1` counts all fenced code blocks, not only Mermaid blocks. Use
-`/copy mermaid N` when you want the Mermaid-specific sequence shown in the
-rendered title.
-
-## LaTeX Math
-
-Matilda Code supports basic inline and block LaTeX rendering in the terminal:
-
-```markdown
-Inline math: $x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$
-
-$$
-\sum_{n=1}^{\infty} 1/n^2 = \pi^2/6
-$$
-```
-
-The renderer focuses on common symbols and readable terminal output. It is not
-a full TeX engine; complex layouts such as matrices, aligned equations, and
-large nested expressions may be simplified.
-
-Inline `$...$` expressions are intentionally bounded to 1024 characters per
-line so malformed or very large generated Markdown cannot stall terminal
-rendering. Longer formulas remain visible as source text and can still be
-copied from raw mode or the original response.
-
-### LaTeX Source Copy
-
-Use these commands to copy LaTeX source from the last AI response:
-
-| Command                | Behavior                                |
-| ---------------------- | --------------------------------------- |
-| `/copy latex`          | Copies the last block LaTeX expression. |
-| `/copy latex 2`        | Copies the second block expression.     |
-| `/copy latex inline`   | Copies the last inline expression.      |
-| `/copy latex inline 2` | Copies the second inline expression.    |
-| `/copy inline-latex 2` | Alias for `/copy latex inline 2`.       |
-
-Inline LaTeX does not show a per-expression copy hint in rendered text to avoid
-making prose noisy. Switch to raw mode with `Alt/Option+M` when you want to
-inspect inline source in place; on macOS this requires Option-as-Meta terminal
-input.
-
-## General Code Copy
-
-The `/copy code` command reads fenced code blocks from the last AI Markdown
-response:
-
-| Command                 | Behavior                                 |
-| ----------------------- | ---------------------------------------- |
-| `/copy code`            | Copies the last fenced code block.       |
-| `/copy code 2`          | Copies the second fenced code block.     |
-| `/copy code typescript` | Copies the last `typescript` code block. |
-| `/copy code mermaid 1`  | Copies the first `mermaid` code block.   |
-
-## Selecting an Earlier AI Message
-
-By default `/copy` targets the most recent AI message. Prefix the command with
-a positive integer to copy from the Nth-last AI message instead — handy when
-the latest reply is something low-signal (e.g., a TODO update) and the
-substantive output is one or two turns back.
-
-| Command               | Behavior                                               |
-| --------------------- | ------------------------------------------------------ |
-| `/copy 2`             | Copies the second-to-last AI message in full.          |
-| `/copy 3`             | Copies the third-to-last AI message in full.           |
-| `/copy 2 code python` | Copies the last `python` code block from the 2nd-last. |
-| `/copy 3 latex`       | Copies the last LaTeX block from the 3rd-last message. |
-
-`/copy 1` is equivalent to `/copy`. If `N` exceeds the number of AI messages
-in the session, `/copy` reports the actual count instead of copying anything.
-Without a leading integer, sub-selectors such as `/copy code python 2` keep
-their existing meaning (the 2nd `python` block in the last message).
-
-## Current Limits
-
-- Mermaid image rendering depends on Mermaid CLI plus terminal image support.
-- Async iTerm2 inline image placement is disabled in the TUI because the
-  protocol is cursor-position bound; use Kitty/Ghostty or ANSI fallback for
-  interactive image previews.
-- Wireframe Mermaid rendering is a readable terminal preview, not a full
-  Mermaid layout engine.
-- Raw mode is global for rendered Markdown blocks; it is not a per-block toggle.
-- LaTeX rendering covers common symbols and expressions, not full TeX layout.
-- Source copy commands target the last AI response by default, or the Nth-last
-  when invoked as `/copy N ...`.

package/bundled/mainy/docs/features/mcp.md

@@ -1,423 +0,0 @@
-# Connect Matilda Code to tools via MCP
-
-Matilda Code can connect to external tools and data sources through the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction). MCP servers give Matilda Code access to your tools, databases, and APIs.
-
-## What you can do with MCP
-
-With MCP servers connected, you can ask Matilda Code to:
-
-- Work with files and repos (read/search/write, depending on the tools you enable)
-- Query databases (schema inspection, queries, reporting)
-- Integrate internal services (wrap your APIs as MCP tools)
-- Automate workflows (repeatable tasks exposed as tools/prompts)
-
-> [!tip]
->
-> If you’re looking for the “one command to get started”, jump to [Quick start](#quick-start).
-
-## Quick start
-
-Matilda Code loads MCP servers from `mcpServers` in your `settings.json`. You can configure servers either:
-
-- By editing `settings.json` directly
-- By using `matilda mcp` commands (see [CLI reference](#matilda-mcp-cli))
-
-### Add your first server
-
-1. Add a server (example: remote HTTP MCP server):
-
-```bash
-matilda mcp add --transport http my-server http://localhost:3000/mcp
-```
-
-2. Open MCP management dialog to view and manage servers:
-
-```bash
-matilda mcp
-```
-
-3. Restart Matilda Code in the same project (or start it if it wasn’t running yet), then ask the model to use tools from that server.
-
-## Where configuration is stored (scopes)
-
-Most users only need these two scopes:
-
-- **Project scope (default)**: `.matilda/settings.json` in your project root
-- **User scope**: `~/.matilda/settings.json` across all projects on your machine
-
-Write to user scope:
-
-```bash
-matilda mcp add --scope user --transport http my-server http://localhost:3000/mcp
-```
-
-> [!tip]
->
-> For advanced configuration layers (system defaults/system settings and precedence rules), see [Settings](../configuration/settings).
-
-## Configure servers
-
-### Choose a transport
-
-| Transport | When to use                                                       | JSON field(s)                               |
-| --------- | ----------------------------------------------------------------- | ------------------------------------------- |
-| `http`    | Recommended for remote services; works well for cloud MCP servers | `httpUrl` (+ optional `headers`)            |
-| `sse`     | Legacy/deprecated servers that only support Server-Sent Events    | `url` (+ optional `headers`)                |
-| `stdio`   | Local process (scripts, CLIs, Docker) on your machine             | `command`, `args` (+ optional `cwd`, `env`) |
-
-> [!note]
->
-> If a server supports both, prefer **HTTP** over **SSE**.
-
-### Configure via `settings.json` vs `matilda mcp add`
-
-Both approaches produce the same `mcpServers` entries in your `settings.json`—use whichever you prefer.
-
-#### Stdio server (local process)
-
-JSON (`.matilda/settings.json`):
-
-```json
-{
-  "mcpServers": {
-    "pythonTools": {
-      "command": "python",
-      "args": ["-m", "my_mcp_server", "--port", "8080"],
-      "cwd": "./mcp-servers/python",
-      "env": {
-        "DATABASE_URL": "$DB_CONNECTION_STRING",
-        "API_KEY": "${EXTERNAL_API_KEY}"
-      },
-      "timeout": 15000
-    }
-  }
-}
-```
-
-CLI (writes to project scope by default):
-
-```bash
-matilda mcp add pythonTools -e DATABASE_URL=$DB_CONNECTION_STRING -e API_KEY=$EXTERNAL_API_KEY \
-  --timeout 15000 python -m my_mcp_server --port 8080
-```
-
-#### HTTP server (remote streamable HTTP)
-
-JSON:
-
-```json
-{
-  "mcpServers": {
-    "httpServerWithAuth": {
-      "httpUrl": "http://localhost:3000/mcp",
-      "headers": {
-        "Authorization": "Bearer your-api-token"
-      },
-      "timeout": 5000
-    }
-  }
-}
-```
-
-CLI:
-
-```bash
-matilda mcp add --transport http httpServerWithAuth http://localhost:3000/mcp \
-  --header "Authorization: Bearer your-api-token" --timeout 5000
-```
-
-#### SSE server (remote Server-Sent Events)
-
-JSON:
-
-```json
-{
-  "mcpServers": {
-    "sseServer": {
-      "url": "http://localhost:8080/sse",
-      "timeout": 30000
-    }
-  }
-}
-```
-
-CLI:
-
-```bash
-matilda mcp add --transport sse sseServer http://localhost:8080/sse --timeout 30000
-```
-
-## Progressive availability and discovery timeouts
-
-Matilda Code discovers MCP servers in the background after the UI is already
-interactive. You see the cli's first prompt within a few hundred
-milliseconds even when one of your MCP servers takes several seconds
-(or never responds), and the model's tool list updates within roughly
-one frame (~16 ms) of each server completing its discover handshake.
-
-- **Interactive mode**: the UI appears immediately; an MCP status pill in
-  the bottom-right shows `N/M MCP servers ready` while discovery is in
-  flight. Sending a prompt before MCP finishes simply means the model
-  sees the tools that are ready _at that moment_; subsequent prompts see
-  more tools as servers come online.
-- **Non-interactive mode** (`--prompt`, stream-json, ACP): the cli still
-  waits for MCP discovery to settle before sending the first prompt, so
-  scripted / piped invocations see the same complete tool set the
-  legacy synchronous behavior produced.
-
-### Per-server `discoveryTimeoutMs`
-
-Each MCP server gets a discovery-only timeout that caps how long the
-initial handshake (`connect` + `tools/list` + `prompts/list` +
-`resources/list`) is allowed to take. Defaults:
-
-- **stdio servers**: 30 s
-- **remote HTTP / SSE servers**: 5 s (network risk is higher)
-
-Override per server when needed:
-
-```jsonc
-{
-  "mcpServers": {
-    "slow-stdio": {
-      "command": "node",
-      "args": ["./slow-server.js"],
-      "discoveryTimeoutMs": 60000,
-    },
-    "flaky-remote": {
-      "httpUrl": "https://example.com/mcp",
-      "discoveryTimeoutMs": 10000,
-    },
-  },
-}
-```
-
-The existing `timeout` field is **tool-call** timeout (used for each
-`tools/call` request, default 10 minutes) and is unaffected by
-`discoveryTimeoutMs` — a long-running tool invocation is not a startup
-pathology.
-
-### Rolling back progressive MCP
-
-If you need the old synchronous behavior (cli waits for every MCP server
-before showing any UI), set `MATILDA_CODE_LEGACY_MCP_BLOCKING=1` in your
-environment. This is kept as an escape hatch for at least one release.
-
-## Safety and control
-
-### Trust (skip confirmations)
-
-- **Server trust** (`trust: true`): bypasses confirmation prompts for that server (use sparingly).
-
-### OAuth authentication
-
-Matilda Code supports OAuth 2.0 authentication for MCP servers. This is useful when accessing remote servers that require authentication.
-
-#### Basic usage
-
-When you add an MCP server with OAuth credentials, Matilda Code will automatically handle the authentication flow:
-
-```bash
-matilda mcp add --transport sse oauth-server https://api.example.com/sse/ \
-  --oauth-client-id your-client-id \
-  --oauth-redirect-uri https://your-server.com/oauth/callback \
-  --oauth-authorization-url https://provider.example.com/authorize \
-  --oauth-token-url https://provider.example.com/token
-```
-
-#### Important: Redirect URI configuration
-
-The OAuth flow requires a redirect URI where the authorization provider sends the authentication code.
-
-- **Local development**: By default, Matilda Code uses `http://localhost:7777/callback`. This works when running Matilda Code on your local machine with a local browser.
-
-- **Remote/cloud deployments**: When running Matilda Code on remote servers, cloud IDEs, or web terminals, the default `localhost` redirect will NOT work. You MUST configure `--oauth-redirect-uri` to point to a publicly accessible URL that can receive the OAuth callback.
-
-Example for remote servers:
-
-```bash
-matilda mcp add --transport sse remote-server https://api.example.com/sse/ \
-  --oauth-redirect-uri https://your-remote-server.example.com/oauth/callback
-```
-
-#### Manual configuration via settings.json
-
-You can also configure OAuth by editing `settings.json` directly:
-
-```json
-{
-  "mcpServers": {
-    "oauthServer": {
-      "url": "https://api.example.com/sse/",
-      "oauth": {
-        "enabled": true,
-        "clientId": "your-client-id",
-        "clientSecret": "your-client-secret",
-        "authorizationUrl": "https://provider.example.com/authorize",
-        "tokenUrl": "https://provider.example.com/token",
-        "redirectUri": "https://your-server.com/oauth/callback",
-        "scopes": ["read", "write"]
-      }
-    }
-  }
-}
-```
-
-OAuth configuration properties:
-
-| Property           | Description                                                                                                           |
-| ------------------ | --------------------------------------------------------------------------------------------------------------------- |
-| `enabled`          | Enable OAuth for this server (boolean)                                                                                |
-| `clientId`         | OAuth client identifier (string, optional with dynamic registration)                                                  |
-| `clientSecret`     | OAuth client secret (string, optional for public clients)                                                             |
-| `authorizationUrl` | OAuth authorization endpoint (string, auto-discovered if omitted)                                                     |
-| `tokenUrl`         | OAuth token endpoint (string, auto-discovered if omitted)                                                             |
-| `scopes`           | Required OAuth scopes (array of strings)                                                                              |
-| `redirectUri`      | Custom redirect URI (string). **Critical for remote deployments**. Defaults to `http://localhost:7777/callback` |
-| `tokenParamName`   | Query parameter name for tokens in SSE URLs (string)                                                                  |
-| `audiences`        | Audiences the token is valid for (array of strings)                                                                   |
-
-#### Token management
-
-OAuth tokens are automatically:
-
-- **Stored securely** in `~/.matilda/mcp-oauth-tokens-v2.json` (AES-256-GCM encrypted), with keychain storage preferred when available
-- **Refreshed** when expired (if refresh tokens are available)
-- **Validated** before each connection attempt
-
-Use the `/mcp auth` command within Matilda Code to manage OAuth authentication interactively.
-
-### Tool filtering (allow/deny tools per server)
-
-Use `includeTools` / `excludeTools` to restrict tools exposed by a server (from Matilda Code’s perspective).
-
-Example: include only a few tools:
-
-```json
-{
-  "mcpServers": {
-    "filteredServer": {
-      "command": "python",
-      "args": ["-m", "my_mcp_server"],
-      "includeTools": ["safe_tool", "file_reader", "data_processor"],
-      "timeout": 30000
-    }
-  }
-}
-```
-
-### Global allow/deny lists
-
-The `mcp` object in your `settings.json` defines global rules for all MCP servers:
-
-- `mcp.allowed`: allow-list of MCP server names (keys in `mcpServers`)
-- `mcp.excluded`: deny-list of MCP server names
-
-Example:
-
-```json
-{
-  "mcp": {
-    "allowed": ["my-trusted-server"],
-    "excluded": ["experimental-server"]
-  }
-}
-```
-
-## Troubleshooting
-
-- **Server shows “Disconnected” in `matilda mcp list`**: verify the URL/command is correct, then increase `timeout`.
-- **Stdio server fails to start**: use an absolute `command` path, and double-check `cwd`/`env`.
-- **Environment variables in JSON don’t resolve**: ensure they exist in the environment where Matilda Code runs (shell vs GUI app environments can differ).
-
-## Reference
-
-### `settings.json` structure
-
-#### Server-specific configuration (`mcpServers`)
-
-Add an `mcpServers` object to your `settings.json` file:
-
-```json
-// ... file contains other config objects
-{
-  "mcpServers": {
-    "serverName": {
-      "command": "path/to/server",
-      "args": ["--arg1", "value1"],
-      "env": {
-        "API_KEY": "$MY_API_TOKEN"
-      },
-      "cwd": "./server-directory",
-      "timeout": 30000,
-      "trust": false
-    }
-  }
-}
-```
-
-Configuration properties:
-
-Required (one of the following):
-
-| Property  | Description                                            |
-| --------- | ------------------------------------------------------ |
-| `command` | Path to the executable for Stdio transport             |
-| `url`     | SSE endpoint URL (e.g., `"http://localhost:8080/sse"`) |
-| `httpUrl` | HTTP streaming endpoint URL                            |
-
-Optional:
-
-| Property               | Type/Default                 | Description                                                                                                                                                                                                                                                       |
-| ---------------------- | ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `args`                 | array                        | Command-line arguments for Stdio transport                                                                                                                                                                                                                        |
-| `headers`              | object                       | Custom HTTP headers when using `url` or `httpUrl`                                                                                                                                                                                                                 |
-| `env`                  | object                       | Environment variables for the server process. Values can reference environment variables using `$VAR_NAME` or `${VAR_NAME}` syntax                                                                                                                                |
-| `cwd`                  | string                       | Working directory for Stdio transport                                                                                                                                                                                                                             |
-| `timeout`              | number<br>(default: 600,000) | Request timeout in milliseconds (default: 600,000ms = 10 minutes)                                                                                                                                                                                                 |
-| `trust`                | boolean<br>(default: false)  | When `true`, bypasses all tool call confirmations for this server (default: `false`)                                                                                                                                                                              |
-| `includeTools`         | array                        | List of tool names to include from this MCP server. When specified, only the tools listed here will be available from this server (allowlist behavior). If not specified, all tools from the server are enabled by default.                                       |
-| `excludeTools`         | array                        | List of tool names to exclude from this MCP server. Tools listed here will not be available to the model, even if they are exposed by the server.<br>Note: `excludeTools` takes precedence over `includeTools` - if a tool is in both lists, it will be excluded. |
-| `targetAudience`       | string                       | The OAuth Client ID allowlisted on the IAP-protected application you are trying to access. Used with `authProviderType: 'service_account_impersonation'`.                                                                                                         |
-| `targetServiceAccount` | string                       | The email address of the Google Cloud Service Account to impersonate. Used with `authProviderType: 'service_account_impersonation'`.                                                                                                                              |
-
-<a id="matilda-mcp-cli"></a>
-
-### Manage MCP servers with `matilda mcp`
-
-You can always configure MCP servers by manually editing `settings.json`, but the CLI is usually faster.
-
-#### Adding a server (`matilda mcp add`)
-
-```bash
-matilda mcp add [options] <name> <commandOrUrl> [args...]
-```
-
-| Argument/Option             | Description                                                         | Default                                | Example                                                            |
-| --------------------------- | ------------------------------------------------------------------- | -------------------------------------- | ------------------------------------------------------------------ |
-| `<name>`                    | A unique name for the server.                                       | —                                      | `example-server`                                                   |
-| `<commandOrUrl>`            | The command to execute (for `stdio`) or the URL (for `http`/`sse`). | —                                      | `/usr/bin/python` or `http://localhost:8`                          |
-| `[args...]`                 | Optional arguments for a `stdio` command.                           | —                                      | `--port 5000`                                                      |
-| `-s`, `--scope`             | Configuration scope (user or project).                              | `project`                              | `-s user`                                                          |
-| `-t`, `--transport`         | Transport type (`stdio`, `sse`, `http`).                            | `stdio`                                | `-t sse`                                                           |
-| `-e`, `--env`               | Set environment variables.                                          | —                                      | `-e KEY=value`                                                     |
-| `-H`, `--header`            | Set HTTP headers for SSE and HTTP transports.                       | —                                      | `-H "X-Api-Key: abc123"`                                           |
-| `--timeout`                 | Set connection timeout in milliseconds.                             | —                                      | `--timeout 30000`                                                  |
-| `--trust`                   | Trust the server (bypass all tool call confirmation prompts).       | — (`false`)                            | `--trust`                                                          |
-| `--description`             | Set the description for the server.                                 | —                                      | `--description "Local tools"`                                      |
-| `--include-tools`           | A comma-separated list of tools to include.                         | all tools included                     | `--include-tools mytool,othertool`                                 |
-| `--exclude-tools`           | A comma-separated list of tools to exclude.                         | none                                   | `--exclude-tools mytool`                                           |
-| `--oauth-client-id`         | OAuth client ID for MCP server authentication.                      | —                                      | `--oauth-client-id your-client-id`                                 |
-| `--oauth-client-secret`     | OAuth client secret for MCP server authentication.                  | —                                      | `--oauth-client-secret your-client-secret`                         |
-| `--oauth-redirect-uri`      | OAuth redirect URI for authentication callback.                     | `http://localhost:7777/callback` | `--oauth-redirect-uri https://your-server.com/oauth/callback`      |
-| `--oauth-authorization-url` | OAuth authorization URL.                                            | —                                      | `--oauth-authorization-url https://provider.example.com/authorize` |
-| `--oauth-token-url`         | OAuth token URL.                                                    | —                                      | `--oauth-token-url https://provider.example.com/token`             |
-| `--oauth-scopes`            | OAuth scopes (comma-separated).                                     | —                                      | `--oauth-scopes scope1,scope2`                                     |
-
-> `--oauth-*` flags apply only to `--transport sse` and `--transport http`. Combining them with `--transport stdio` is rejected.
-
-#### Removing a server (`matilda mcp remove`)
-
-```bash
-matilda mcp remove <name>
-```