typst-mcp 1.1.0 → 1.2.0

package/README.md

@@ -18,19 +18,25 @@
 ### Prerequisites
 
 - [**Node.js**](https://nodejs.org/) `>= 18` (for `npx` install) or [**Bun**](https://bun.sh) `>= 1.2` (for local development)
-- [**Typst CLI**](https://github.com/typst/typst) (`typst` on `PATH` for `typst_get_diagnostics` and `typst_export_pdf`)
+- [**Typst CLI**](https://github.com/typst/typst) (optional: `typst` on `PATH` for local CLI compilation speed; if not installed, `typst_get_diagnostics` automatically uses Typst Web cloud compiler diagnostics)
 
 ### Installation
 
-**Recommended — no clone, no global install:**
+**Option 1: Quick start (no clone, no global install):**
 
 ```bash
 npx -y typst-mcp
 ```
 
-Runs the published [`typst-mcp`](https://www.npmjs.com/package/typst-mcp) package (Node `>= 18`). Use the same command in MCP config below. `-y` skips the npx install prompt.
+**Option 2: Always run latest release (bypasses local `npx` cache):**
 
-**From source (development):**
+```bash
+npx -y typst-mcp@latest
+```
+
+Runs the published [`typst-mcp`](https://www.npmjs.com/package/typst-mcp) package (Node `>= 18`). `-y` skips the npx confirmation prompt.
+
+**Option 3: From source (development):**
 
 ```bash
 git clone https://github.com/caphefalumi/typst-web-mcp.git
@@ -58,6 +64,8 @@ Add `typst-mcp` to your MCP client configuration (`.pi/agent/mcp-adapter.json`,
 }
 ```
 
+> **Tip:** You can also set `"args": ["-y", "typst-mcp@latest"]` to guarantee your MCP client automatically pulls and runs the newest version on launch.
+
 > **Session Persistence:** Once authenticated via `typst_auth_login` (or environment variables), the `__Http-typst-session` cookie is cached locally at `~/.pi/agent/typst-mcp-session.json` so subsequent tool calls authenticate automatically without re-signing in.
 
 ---
@@ -74,21 +82,6 @@ Add `typst-mcp` to your MCP client configuration (`.pi/agent/mcp-adapter.json`,
 
 ---
 
-## Architecture
-
-```mermaid
-flowchart LR
-    Agent["AI Agent\n(Pi / Claude / Cursor)"] <-->|"JSON-RPC (stdio)"| MCP["typst-mcp\n(Node / TypeScript)"]
-    MCP <-->|"GraphQL (/v1/graphql)\n+ X-Typst-Preflight"| API["https://api.typst.app"]
-    MCP <-->|"REST Yjs & Blobs\n(/v1/files/:pid/:fid/yjs)"| API
-    MCP <-->|"Binary lib0 WebSocket\n(wss://api.typst.app/editing/v3)"| WS["typst.app Real-Time Sync"]
-    MCP -->|"Workspace Sync + Compile"| TypstCLI["Typst Compiler\n(Diagnostics & PDF)"]
-```
-
-See [`docs/PROTOCOL.md`](./docs/PROTOCOL.md) for the complete reverse-engineered protocol specification.
-
----
-
 ## MCP Tools (18 Tools)
 
 | Category | Tool Name | Description |
@@ -108,7 +101,7 @@ See [`docs/PROTOCOL.md`](./docs/PROTOCOL.md) for the complete reverse-engineered
 | **Assets & Tree** | `typst_upload_asset` | Upload or replace binary assets (`PNG`, `JPG`, `SVG`, `PDF`, fonts) from a local path or base64 payload. |
 | **Assets & Tree** | `typst_rename_file` | Rename or move a file inside a `typst.app` project (`UpdatesFileMutation`). |
 | **Assets & Tree** | `typst_delete_file` | Delete a file or binary asset from a project (`DeleteFilesMutation`). |
-| **Compiler** | `typst_get_diagnostics` | Sync all cloud files and run `typst compile` to return structured errors, warnings, line/column spans, and hints. |
+| **Compiler** | `typst_get_diagnostics` | Retrieve compiler diagnostics (errors, warnings, line/column numbers, and hints). Supports both local Typst CLI (`mode="cli"`) and Typst Web cloud compiler (`mode="web"`), with automatic fallback (`mode="auto"`). |
 | **Compiler** | `typst_export_pdf` | Sync all cloud text & binary assets, compile the project to PDF, and save to `outputPath`. |
 | **Preview** | `typst_capture_screenshot` | Capture high-DPI PNG preview screenshots (`mode="pages"` renders compiled PNG pages; `mode="browser"` screenshots the live `typst.app` web UI). |
 
@@ -143,36 +136,6 @@ Same flow as [Canvas-CLI](https://github.com/caphefalumi/Canvas-CLI):
 
 **Trusted publisher (maintainers):** package [`typst-mcp`](https://www.npmjs.com/package/typst-mcp) → Settings → Trusted publishing → GitHub Actions — user/org `caphefalumi`, repo `typst-web-mcp`, workflow file `npm-publish.yml`, environment `npm-publish`, allow **npm publish**.
 
-### Project Structure
-
-```text
-typst-web-mcp/
-├── docs/
-│   └── PROTOCOL.md              # Reverse-engineered typst.app REST, GraphQL, Yjs & WS v3 spec
-├── src/
-│   ├── protocol/
-│   │   ├── edit-diff.ts         # Fuzzy matching, CRLF/BOM resilience, unified diff & patch generator
-│   │   ├── ws-codec.ts          # Binary lib0 /editing/v3 WebSocket encoder & decoder
-│   │   ├── yjs-doc.ts           # Yjs CRDT text decoding, replacement & surgical patching
-│   │   └── graphql.ts           # GraphQL queries, mutations, fragments & types
-│   ├── client/
-│   │   ├── auth.ts              # Direct /v1/auth/signin login, cookie jar & Playwright fallback
-│   │   ├── compiler.ts          # Typst binary resolver, diagnostic parser, PDF & PNG preview compiler
-│   │   ├── errors.ts            # Structured TypstLoadError & error formatting helpers
-│   │   └── typst-client.ts      # TypstCloudClient (REST, GraphQL, WebSocket v3, Compiler facade)
-│   ├── tools/
-│   │   └── definitions.ts       # MCP JSON Schema definitions for all 16 tools
-│   ├── utils/
-│   │   ├── file-mutation-queue.ts # Serialized mutation mutex queue per file
-│   │   ├── mime.ts              # Image MIME type detection
-│   │   └── truncate.ts          # Dual-limit (line & byte) head/tail truncation utilities
-│   └── index.ts                 # MCP stdio server entrypoint (dev); npm bin runs dist/index.js
-├── test/
-│   └── typst-mcp.test.ts        # 7 test suites (57 assertions) covering codecs, CRDTs & E2E
-├── LICENSE                      # MIT License
-└── package.json
-```
-
 ---
 
 ## License

package/dist/client/compiler.js

@@ -29,6 +29,52 @@ export function resolveTypstBinary(explicitBin) {
     }
     return "typst";
 }
+export function hasTypstBinary(explicitBin) {
+    try {
+        const bin = resolveTypstBinary(explicitBin);
+        if (bin !== "typst" && existsSync(bin)) {
+            return true;
+        }
+        const proc = spawnSync(bin, ["--version"], {
+            stdio: "ignore",
+            encoding: "utf8",
+        });
+        return proc.status === 0 && !proc.error;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolvePythonBinary() {
+    if (process.env.PYTHON_BIN) {
+        return process.env.PYTHON_BIN;
+    }
+    for (const cmd of ["python", "python3", "py"]) {
+        try {
+            const res = spawnSync(cmd, ["--version"], { stdio: "ignore" });
+            if (res.status === 0) {
+                return cmd;
+            }
+        }
+        catch { }
+    }
+    return "python";
+}
+export function offsetToPosition(text, offset) {
+    let line = 1;
+    let column = 1;
+    const target = Math.min(Math.max(0, offset), text.length);
+    for (let i = 0; i < target; i++) {
+        if (text[i] === "\n") {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+    }
+    return { line, column };
+}
 function hasValidPngSignature(bytes) {
     return (bytes.byteLength >= 8 &&
         bytes[0] === 0x89 &&
@@ -95,6 +141,9 @@ export function compileWorkspaceDiagnostics(params) {
         cwd: params.workspaceDir,
         encoding: "utf8",
     });
+    if (proc.error) {
+        throw new TypstLoadError(["TYPST_EXECUTION_FAILED"], `Failed to execute Typst compiler binary '${params.typstBin}': ${proc.error.message}`);
+    }
     const combinedOutput = `${proc.stderr ?? ""}\n${proc.stdout ?? ""}`;
     const diagnostics = parseShortDiagnostics(combinedOutput).map((d) => ({
         ...d,
@@ -130,6 +179,9 @@ export function compileWorkspacePdf(params) {
         cwd: params.workspaceDir,
         encoding: "utf8",
     });
+    if (proc.error) {
+        throw new TypstLoadError(["TYPST_EXECUTION_FAILED"], `Failed to execute Typst compiler binary '${params.typstBin}': ${proc.error.message}`);
+    }
     const combinedOutput = `${proc.stderr ?? ""}\n${proc.stdout ?? ""}`;
     const diagnostics = parseShortDiagnostics(combinedOutput);
     if (proc.status !== 0) {
@@ -148,12 +200,169 @@ export function compileWorkspacePdf(params) {
         diagnostics,
     };
 }
+export function captureWebDiagnostics(params) {
+    const pythonBin = resolvePythonBinary();
+    const timeoutSec = ((params.timeoutMs ?? 25000) / 1000).toFixed(1);
+    const pyScript = `
+import os, sys, json, time
+from playwright.sync_api import sync_playwright
+
+app_url = os.environ.get("TYPST_APP_URL", "https://typst.app")
+proj_id = os.environ["TYPST_PROJ_ID"]
+raw_cookie = os.environ.get("TYPST_COOKIE", "")
+timeout_sec = float(os.environ.get("TYPST_TIMEOUT_SEC", "25.0"))
+
+cookies = []
+for part in raw_cookie.split(";"):
+    part = part.strip()
+    if "=" in part:
+        k, v = part.split("=", 1)
+        name = k.strip()
+        val = v.strip()
+        is_session = "__Http" in name or "session" in name
+        cookies.append({
+            "name": name,
+            "value": val,
+            "domain": ".typst.app",
+            "path": "/",
+            "httpOnly": is_session,
+            "secure": True,
+            "sameSite": "Strict" if is_session else "Lax",
+        })
+
+with sync_playwright() as p:
+    browser = None
+    for channel in ["msedge", "chrome", None]:
+        try:
+            if channel:
+                browser = p.chromium.launch(channel=channel, headless=True)
+            else:
+                browser = p.chromium.launch(headless=True)
+            break
+        except Exception:
+            continue
+
+    if browser is None:
+        sys.stderr.write("NO_BROWSER_FOUND")
+        sys.exit(2)
+
+    ctx = browser.new_context(viewport={"width": 1920, "height": 1080})
+    if cookies:
+        ctx.add_cookies(cookies)
+
+    ctx.add_init_script("""
+        window.__typst_diagnostics = null;
+        window.__typst_status = 'starting';
+        const OrigWorker = window.Worker;
+        window.Worker = function(url, opts) {
+            const w = new OrigWorker(url, opts);
+            w.addEventListener('message', (ev) => {
+                try {
+                    if (ev.data && ev.data.tag === 'notification') {
+                        if (ev.data.name === 'diagnostics') {
+                            window.__typst_diagnostics = ev.data.notification?.diagnostics || [];
+                        } else if (ev.data.name === 'status') {
+                            window.__typst_status = ev.data.notification?.status || 'idle';
+                        }
+                    }
+                } catch(e) {}
+            });
+            return w;
+        };
+    """)
+
+    page = ctx.new_page()
+    page.goto(f"{app_url}/project/{proj_id}", wait_until="commit", timeout=45000)
+
+    start_time = time.time()
+    diags = None
+    while time.time() - start_time < timeout_sec:
+        data = page.evaluate("({ diag: window.__typst_diagnostics, status: window.__typst_status, url: window.location.href })")
+        if "signin" in data.get("url", ""):
+            browser.close()
+            sys.stderr.write(f"AUTH_REQUIRED: Redirected to {data.get('url')}")
+            sys.exit(3)
+        if data.get("diag") is not None:
+            diags = data.get("diag")
+            if data.get("status") == "idle":
+                break
+        page.wait_for_timeout(300)
+
+    browser.close()
+    print(json.dumps(diags or []))
+`;
+    const proc = spawnSync(pythonBin, ["-c", pyScript], {
+        env: {
+            ...process.env,
+            TYPST_APP_URL: params.appUrl,
+            TYPST_PROJ_ID: params.projectId,
+            TYPST_COOKIE: params.cookieHeader,
+            TYPST_TIMEOUT_SEC: timeoutSec,
+        },
+        encoding: "utf8",
+        timeout: (params.timeoutMs ?? 25000) + 15000,
+    });
+    if (proc.error || proc.status !== 0) {
+        const stderr = (proc.stderr || proc.error?.message || "").trim();
+        if (stderr.includes("NO_BROWSER_FOUND")) {
+            throw new TypstLoadError(["NO_BROWSER_FOUND"], "No compatible browser (Edge, Chrome, or Chromium) found for Playwright web diagnostics.");
+        }
+        if (stderr.includes("AUTH_REQUIRED")) {
+            throw new TypstLoadError(["UNAUTHENTICATED"], `Typst Web cloud session expired or invalid: ${stderr}`);
+        }
+        throw new TypstLoadError(["WEB_DIAGNOSTICS_FAILED"], `Failed to capture Typst Web cloud diagnostics: ${stderr || "Ensure python with playwright is installed ('pip install playwright && playwright install')"}`);
+    }
+    const rawJson = (proc.stdout || "").trim();
+    let rawList = [];
+    try {
+        rawList = JSON.parse(rawJson);
+    }
+    catch (err) {
+        throw new TypstLoadError(["WEB_DIAGNOSTICS_PARSE_FAILED"], `Failed to parse Typst Web diagnostics output: ${err.message}`);
+    }
+    const mainFileName = params.mainFile ?? "main.typ";
+    const diagnostics = rawList.map((raw) => {
+        let line = 1;
+        let column = 1;
+        const filePath = raw.path || mainFileName;
+        const fileText = params.fileContents?.[filePath];
+        if (fileText && raw.range?.start !== undefined) {
+            const pos = offsetToPosition(fileText, raw.range.start);
+            line = pos.line;
+            column = pos.column;
+        }
+        return {
+            path: filePath,
+            line,
+            column,
+            severity: raw.severity === "error" ? "error" : "warning",
+            message: raw.message,
+            hints: Array.isArray(raw.hints) ? raw.hints : [],
+            package: raw.package ?? null,
+            range: raw.range
+                ? { start: raw.range.start, end: raw.range.end }
+                : undefined,
+        };
+    });
+    const errorCount = diagnostics.filter((d) => d.severity === "error").length;
+    const warningCount = diagnostics.filter((d) => d.severity === "warning").length;
+    return {
+        projectId: params.projectId,
+        mainFile: mainFileName,
+        mode: "web",
+        success: errorCount === 0,
+        errorCount,
+        warningCount,
+        diagnostics,
+    };
+}
 export function captureBrowserPreviewScreenshot(params) {
     const outputDir = resolveOutputDirectory(params.outputDir, `typst-preview-ui-${params.projectId}-`);
     mkdirSync(outputDir, { recursive: true });
     const screenshotPath = join(outputDir, `typst-app-${params.projectId}.png`);
+    const pythonBin = resolvePythonBinary();
     const pyScript = `
-import os
+import os, sys
 from playwright.sync_api import sync_playwright
 
 app_url = os.environ["TYPST_PREVIEW_APP_URL"]
@@ -166,16 +375,35 @@ for part in raw_cookie.split(";"):
     part = part.strip()
     if "=" in part:
         k, v = part.split("=", 1)
+        name = k.strip()
+        val = v.strip()
+        is_session = "__Http" in name or "session" in name
         cookies.append({
-            "name": k.strip(),
-            "value": v.strip(),
-            "domain": "typst.app",
+            "name": name,
+            "value": val,
+            "domain": ".typst.app",
             "path": "/",
+            "httpOnly": is_session,
             "secure": True,
+            "sameSite": "Strict" if is_session else "Lax",
         })
 
 with sync_playwright() as p:
-    browser = p.chromium.launch(channel="msedge", headless=True)
+    browser = None
+    for channel in ["msedge", "chrome", None]:
+        try:
+            if channel:
+                browser = p.chromium.launch(channel=channel, headless=True)
+            else:
+                browser = p.chromium.launch(headless=True)
+            break
+        except Exception:
+            continue
+
+    if browser is None:
+        sys.stderr.write("NO_BROWSER_FOUND")
+        sys.exit(2)
+
     ctx = browser.new_context(viewport={"width": 1920, "height": 1080}, device_scale_factor=2)
     if cookies:
         ctx.add_cookies(cookies)
@@ -185,7 +413,7 @@ with sync_playwright() as p:
     page.screenshot(path=out_path, full_page=False)
     browser.close()
 `;
-    const proc = spawnSync("python", ["-c", pyScript], {
+    const proc = spawnSync(pythonBin, ["-c", pyScript], {
         env: {
             ...process.env,
             TYPST_PREVIEW_APP_URL: params.appUrl,

package/dist/client/typst-client.js

@@ -3,8 +3,8 @@ import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 import { TypstAuthManager } from "./auth.js";
 import { TypstLoadError, formatUnknownError } from "./errors.js";
-import { captureBrowserPreviewScreenshot, captureWorkspacePageScreenshots, compileWorkspaceDiagnostics, compileWorkspacePdf, parseShortDiagnostics, resolveTypstBinary, } from "./compiler.js";
-import { CREATE_PROJECT_MUTATION, DASHBOARD_CONTENT_QUERY, DELETE_FILES_MUTATION, DELETE_PROJECT_MUTATION, PROJECT_FILES_QUERY, UPDATE_FILES_MUTATION, } from "../protocol/graphql.js";
+import { captureBrowserPreviewScreenshot, captureWebDiagnostics, captureWorkspacePageScreenshots, compileWorkspaceDiagnostics, compileWorkspacePdf, hasTypstBinary, parseShortDiagnostics, resolveTypstBinary, } from "./compiler.js";
+import { CREATE_PROJECT_MUTATION, DASHBOARD_CONTENT_QUERY, DELETE_FILES_MUTATION, DELETE_PROJECT_MUTATION, EDIT_PROJECT_MUTATION, PROJECT_FILES_QUERY, UPDATE_FILES_MUTATION, } from "../protocol/graphql.js";
 import { decodeYjsText, editYjsText, replaceYjsText, } from "../protocol/yjs-doc.js";
 import { decodeMessage, encodeMessage, MessageKind, } from "../protocol/ws-codec.js";
 import { truncateHead, formatSize, } from "../utils/truncate.js";
@@ -571,18 +571,92 @@ export class TypstCloudClient {
     static parseShortDiagnostics(stderrText) {
         return parseShortDiagnostics(stderrText);
     }
-    async getDiagnostics(projectId, mainFile) {
-        const { workspaceDir, mainFileName } = await this.materializeProjectWorkspace(projectId, mainFile);
+    async updateProject(projectId, updates) {
+        const res = await this.graphql(EDIT_PROJECT_MUTATION, {
+            projectId,
+            name: updates.name,
+            previewed: updates.previewed,
+            pinnedVersion: updates.pinnedVersion,
+        });
+        return res.updateProject;
+    }
+    async getWebDiagnostics(projectId, mainFile) {
+        const project = await this.getProject(projectId);
+        let effectiveMainFile = mainFile;
+        if (!effectiveMainFile) {
+            const previewedFile = project.files.find((f) => f.id === project.previewed);
+            effectiveMainFile = previewedFile?.name ?? "main.typ";
+        }
+        else {
+            const requestedFile = project.files.find((f) => f.name === mainFile || f.id === mainFile);
+            if (requestedFile && requestedFile.id !== project.previewed) {
+                try {
+                    await this.updateProject(projectId, { previewed: requestedFile.id });
+                }
+                catch {
+                    // If permission denied or mutation rejected, proceed anyway
+                }
+            }
+        }
+        const fileContents = {};
+        for (const f of project.files) {
+            if (f.isMultiplayable) {
+                try {
+                    const res = await this.readFile(projectId, f.name);
+                    if (res.encoding === "utf-8" && typeof res.content === "string") {
+                        fileContents[f.name] = res.content;
+                    }
+                }
+                catch {
+                    // Ignore read failures for auxiliary files
+                }
+            }
+        }
+        return captureWebDiagnostics({
+            appUrl: this.auth.appUrl,
+            projectId,
+            cookieHeader: this.auth.getCookieHeader(),
+            mainFile: effectiveMainFile,
+            fileContents,
+        });
+    }
+    async getDiagnostics(projectId, options) {
+        const opts = typeof options === "string" ? { mainFile: options } : options;
+        const mode = opts?.mode ?? "auto";
+        const requestedMainFile = opts?.mainFile;
+        if (mode === "web") {
+            return await this.getWebDiagnostics(projectId, requestedMainFile);
+        }
+        const typstAvailable = hasTypstBinary(this.typstBin);
+        if (!typstAvailable) {
+            if (mode === "cli") {
+                throw new TypstLoadError(["TYPST_BINARY_NOT_FOUND"], `Typst compiler binary '${this.typstBin}' was not found. Please install the Typst compiler (e.g. 'winget install Typst.Typst' / 'brew install typst') or use mode: 'web' for zero-binary cloud diagnostics.`);
+            }
+            return await this.getWebDiagnostics(projectId, requestedMainFile);
+        }
         try {
-            return compileWorkspaceDiagnostics({
-                typstBin: this.typstBin,
-                projectId,
-                workspaceDir,
-                mainFileName,
-            });
+            const { workspaceDir, mainFileName } = await this.materializeProjectWorkspace(projectId, requestedMainFile);
+            try {
+                const res = compileWorkspaceDiagnostics({
+                    typstBin: this.typstBin,
+                    projectId,
+                    workspaceDir,
+                    mainFileName,
+                });
+                return {
+                    ...res,
+                    mode: "cli",
+                };
+            }
+            finally {
+                rmSync(workspaceDir, { recursive: true, force: true });
+            }
         }
-        finally {
-            rmSync(workspaceDir, { recursive: true, force: true });
+        catch (err) {
+            if (mode === "auto") {
+                return await this.getWebDiagnostics(projectId, requestedMainFile);
+            }
+            throw err;
         }
     }
     async exportPdf(projectId, options) {

package/dist/index.js

@@ -119,7 +119,10 @@ export async function dispatchTypstTool(client, name, args = {}) {
         case "typst_rename_file":
             return await client.renameFile(String(args.projectId), String(args.filePath), String(args.newName));
         case "typst_get_diagnostics":
-            return await client.getDiagnostics(String(args.projectId), args.mainFile);
+            return await client.getDiagnostics(String(args.projectId), {
+                mainFile: args.mainFile,
+                mode: args.mode,
+            });
         case "typst_export_pdf":
             return await client.exportPdf(String(args.projectId), {
                 mainFile: args.mainFile,

package/dist/tools/definitions.js

@@ -296,7 +296,7 @@ export const TYPST_MCP_TOOLS = [
     },
     {
         name: "typst_get_diagnostics",
-        description: "Synchronize all files from a https://typst.app project and run the Typst compiler to retrieve structured errors, warnings, line/column numbers, and hints.",
+        description: "Retrieve compiler diagnostics (errors, warnings, line/column numbers, and hints) for a https://typst.app project. Supports both local Typst CLI compilation (fastest) and Typst Web cloud diagnostics (zero-binary fallback using typst.app cloud compiler).",
         inputSchema: {
             type: "object",
             properties: {
@@ -308,6 +308,11 @@ export const TYPST_MCP_TOOLS = [
                     type: "string",
                     description: "Optional main .typ entry file override (defaults to project previewed file or main.typ)",
                 },
+                mode: {
+                    type: "string",
+                    enum: ["auto", "cli", "web"],
+                    description: "Diagnostics mode: 'auto' (prefers local Typst CLI if installed, falls back to Typst Web cloud compiler), 'cli' (requires local typst binary), or 'web' (uses Typst Web cloud compiler). Defaults to 'auto'.",
+                },
             },
             required: ["projectId"],
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typst-mcp",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Model Context Protocol (MCP) server for https://typst.app/ cloud projects, Yjs real-time text editing, asset management, and Typst compiler diagnostics",
   "keywords": [
     "mcp",