curatedmcp 2.0.0

package/dist/index.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import { createRequire } from "module";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { searchServers } from "./tools/search.js";
+import { getServerDetails } from "./tools/get-details.js";
+import { installServer } from "./tools/install.js";
+import { listCategories } from "./tools/list-categories.js";
+import { Telemetry } from "./telemetry.js";
+import { runCli, isCliInvocation } from "./cli.js";
+import { Proxy } from "./proxy.js";
+import { readStack } from "./stack.js";
+import { addToStack } from "./cli/add.js";
+const require = createRequire(import.meta.url);
+const VERSION = require("../package.json").version;
+// ─── CLI dispatch ────────────────────────────────────────────────────────────
+// If invoked with subcommand args, run the CLI and exit.
+// Otherwise, fall through to MCP server mode.
+if (isCliInvocation(process.argv)) {
+    runCli(process.argv).then((code) => process.exit(code), (err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}
+else {
+    startMcpServer().catch((err) => {
+        console.error("[launcher] Fatal:", err);
+        process.exit(1);
+    });
+}
+// ─── MCP server (default mode when no CLI args) ──────────────────────────────
+async function startMcpServer() {
+    const telemetry = new Telemetry();
+    const proxy = new Proxy();
+    // Load user's stack and lazy-spawn child MCP servers.
+    // Failures here are logged but don't crash launcher — user gets discovery tools at minimum.
+    const stack = readStack();
+    if (stack.entries.length > 0) {
+        await proxy.loadStack(stack).catch((err) => {
+            console.error("[launcher] Stack load error:", err);
+        });
+    }
+    const server = new Server({
+        name: "curatedmcp-launcher",
+        version: VERSION,
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // ─── tools/list: discovery + proxied tools ─────────────────────────────────
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const proxiedTools = await proxy.aggregateTools();
+        return {
+            tools: [...DISCOVERY_TOOLS, ...proxiedTools],
+        };
+    });
+    // ─── tools/call: route by name ─────────────────────────────────────────────
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const argObj = (args || {});
+        // Proxied tools have a "<slug>__<original>" prefix
+        if (name.includes("__")) {
+            try {
+                return await proxy.routeCall(name, argObj);
+            }
+            catch (err) {
+                return errorResponse(err);
+            }
+        }
+        // Discovery tools
+        try {
+            await telemetry.logEvent({
+                event: name.replace(/_/g, "-"),
+                slug: argObj.slug || null,
+                client: argObj.client || null,
+                query: argObj.query || null,
+            });
+            switch (name) {
+                case "search_servers": {
+                    const results = await searchServers({
+                        query: argObj.query,
+                        category: argObj.category,
+                        limit: argObj.limit,
+                    });
+                    const text = `Found ${results.length} MCP server(s):\n\n` +
+                        results
+                            .map((s) => `**${s.name}** (${s.category})\n` +
+                            `${s.tagline}\n` +
+                            `Pricing: ${s.pricing} | Rating: ${s.rating ?? "N/A"} | Downloads: ${s.downloads}\n` +
+                            `Slug: \`${s.slug}\``)
+                            .join("\n\n") +
+                        `\n\nNext steps:\n` +
+                        `• \`get_server_details\` for full info on any server\n` +
+                        `• \`add_to_stack\` to add a server to this Launcher (becomes available in your AI client after restart)\n` +
+                        `• \`install_server\` for the manual install snippet`;
+                    return { content: [{ type: "text", text }] };
+                }
+                case "get_server_details": {
+                    const details = await getServerDetails(argObj.slug);
+                    const text = `# ${details.name}\n\n${details.description}\n\n` +
+                        `**Pricing:** ${details.pricingType}\n` +
+                        `**Category:** ${details.category}\n` +
+                        `**Rating:** ${details.rating ?? "N/A"}\n` +
+                        `**Downloads:** ${details.downloadCount}\n\n` +
+                        `**Repository:** ${details.repo || "N/A"}\n` +
+                        `**Docs:** ${details.docsUrl || "N/A"}\n\n` +
+                        `Add this server to your Launcher stack with:\n` +
+                        `\`add_to_stack\` (slug: "${details.slug}")\n` +
+                        `Or get the manual install snippet with \`install_server\`.`;
+                    return { content: [{ type: "text", text }] };
+                }
+                case "install_server": {
+                    const config = await installServer(argObj.slug, (argObj.client || "claude"));
+                    return { content: [{ type: "text", text: config }] };
+                }
+                case "list_categories": {
+                    const categories = listCategories();
+                    const text = `Available MCP server categories:\n\n${categories.map((c) => `• ${c}`).join("\n")}\n\n` +
+                        `Use the category parameter in search_servers to filter results.`;
+                    return { content: [{ type: "text", text }] };
+                }
+                case "add_to_stack": {
+                    const slug = argObj.slug;
+                    if (!slug)
+                        throw new Error("slug is required");
+                    const result = await addToStack(slug, {
+                        env: argObj.env || {},
+                        nonInteractive: true,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Added \`${slug}\` to your Launcher stack.\n\n` +
+                                    `${result.summary}\n\n` +
+                                    `**Restart your AI client** for the new tools to appear. ` +
+                                    `They'll be exposed as \`${slug}__<tool>\`.`,
+                            },
+                        ],
+                    };
+                }
+                default:
+                    return {
+                        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                        isError: true,
+                    };
+            }
+        }
+        catch (err) {
+            return errorResponse(err);
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`[launcher] v${VERSION} ready (stack: ${stack.entries.length} server(s))`);
+    // Graceful shutdown
+    const shutdown = async () => {
+        await proxy.shutdown().catch(() => { });
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+// ─── Static tool definitions ─────────────────────────────────────────────────
+const DISCOVERY_TOOLS = [
+    {
+        name: "search_servers",
+        description: "Search the CuratedMCP catalog for MCP servers by keyword, category, or use case",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query (e.g. 'GitHub', 'database', 'Stripe')",
+                },
+                category: {
+                    type: "string",
+                    enum: [
+                        "DEVELOPER_TOOLS",
+                        "WEB_AUTOMATION",
+                        "DATABASE",
+                        "CLOUD_SERVICES",
+                        "AI_AGENTS",
+                        "PRODUCTIVITY",
+                        "COMMUNICATION",
+                        "ANALYTICS",
+                    ],
+                    description: "Filter by category",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results (default 10, max 50)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_server_details",
+        description: "Get full details about a specific MCP server including install instructions",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "Server slug (from search results)" },
+            },
+            required: ["slug"],
+        },
+    },
+    {
+        name: "install_server",
+        description: "Get the manual install configuration snippet for an MCP server (use add_to_stack instead if you want it managed by Launcher)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: { type: "string", description: "Server slug" },
+                client: {
+                    type: "string",
+                    enum: ["claude", "cursor", "windsurf"],
+                    description: "Target client (default: claude)",
+                },
+            },
+            required: ["slug"],
+        },
+    },
+    {
+        name: "list_categories",
+        description: "List all available MCP server categories",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "add_to_stack",
+        description: "Add an MCP server to your Launcher stack so its tools become available through Launcher in every AI client. The server's tools appear as `<slug>__<tool>` after the AI client is restarted.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: {
+                    type: "string",
+                    description: "Server slug from the CuratedMCP catalog (use search_servers to find one)",
+                },
+                env: {
+                    type: "object",
+                    description: "Environment variables for the server (e.g. API keys). Required env vars must be supplied here.",
+                    additionalProperties: { type: "string" },
+                },
+            },
+            required: ["slug"],
+        },
+    },
+];
+function errorResponse(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/proxy.d.ts

@@ -0,0 +1,122 @@
+import type { Stack } from "./stack.js";
+/** A tool, as returned by an MCP server's tools/list. */
+interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema: unknown;
+}
+export declare class Proxy {
+    private children;
+    /**
+     * Spawn each enabled child in parallel. A single failure is logged but
+     * doesn't abort the whole load — partial proxying is better than none.
+     */
+    loadStack(stack: Stack): Promise<void>;
+    private spawnChild;
+    /**
+     * Returns all tools from all healthy children, prefixed with `<slug>__`.
+     * Disabled or unhealthy children contribute nothing.
+     */
+    aggregateTools(): Promise<McpTool[]>;
+    /**
+     * Route a `<slug>__<tool>` call to the right child and return its response unchanged.
+     * Throws if the prefix doesn't match any known child or if the child is unhealthy.
+     */
+    routeCall(prefixedName: string, args: Record<string, unknown>): Promise<{
+        [x: string]: unknown;
+        content: ({
+            type: "text";
+            text: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "audio";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                text: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                blob: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            };
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            name: string;
+            type: "resource_link";
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            size?: number | undefined;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        structuredContent?: Record<string, unknown> | undefined;
+        isError?: boolean | undefined;
+    } | {
+        [x: string]: unknown;
+        toolResult: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    /** Cleanly close all child clients. Best-effort; never throws. */
+    shutdown(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=proxy.d.ts.map

package/dist/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,YAAY,CAAC;AAIpD,yDAAyD;AACzD,UAAU,OAAO;IACf,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;CACtB;AAWD,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAAiC;IAEjD;;;OAGG;IACG,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;YAK9B,UAAU;IA6CxB;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IA0B1C;;;OAGG;IACG,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;uBAsE82U,CAAC;wBAA4B,CAAC;wBAAgE,CAAC;4BAAkD,CAAC;;iBAAkE,CAAC;;;;;uBAA+J,CAAC;wBAA4B,CAAC;wBAAgE,CAAC;4BAAkD,CAAC;;iBAAkE,CAAC;;;;;uBAA+J,CAAC;wBAA4B,CAAC;wBAAgE,CAAC;4BAAkD,CAAC;;iBAAkE,CAAC;;;;;;wBAA8L,CAAC;qBAA2C,CAAC;;;;wBAA4I,CAAC;qBAA2C,CAAC;;uBAA6E,CAAC;wBAA4B,CAAC;wBAAgE,CAAC;4BAAkD,CAAC;;iBAAkE,CAAC;;;;;uBAAkK,CAAC;oBAA0C,CAAC;gBAAsC,CAAC;uBAA6C,CAAC;wBAA4B,CAAC;wBAAgE,CAAC;4BAAkD,CAAC;;iBAAkE,CAAC;;;iBAAsF,CAAC;;wBAAyD,CAAC;qBAA2C,CAAC;qBAA6C,CAAC;;iBAA8E,CAAC;;;;yBAAiH,CAAC;kDAAiF,CAAC;;;;;;;;;;;yBAAgV,CAAC;kDAAiF,CAAC;;;;;IA5C58a,kEAAkE;IAC5D,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAQhC"}

package/dist/proxy.js

@@ -0,0 +1,165 @@
+/**
+ * Proxy — spawns child MCP servers from the user's stack and aggregates their tools.
+ *
+ * Architecture:
+ *   Agent (Claude/Cursor/...) --> Launcher (parent MCP server)
+ *                                      |
+ *                                      +--> child Client #1 -- stdio --> server #1 process
+ *                                      +--> child Client #2 -- stdio --> server #2 process
+ *                                      +--> ...
+ *
+ * Tool name routing:
+ *   Each child's tools are exposed to the agent with a `<slug>__<original_name>` prefix.
+ *   On tools/call, we strip the prefix and forward to the right child.
+ *
+ * Failure isolation:
+ *   - Children are loaded lazily and in parallel; one failing to connect doesn't block others
+ *   - On a child crash mid-session, the proxy marks it unhealthy and surfaces a clean error
+ *     to the agent rather than crashing Launcher itself
+ *   - Children with "disabled: true" in stack.json are skipped entirely
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+const PREFIX_SEPARATOR = "__";
+export class Proxy {
+    constructor() {
+        this.children = new Map();
+    }
+    /**
+     * Spawn each enabled child in parallel. A single failure is logged but
+     * doesn't abort the whole load — partial proxying is better than none.
+     */
+    async loadStack(stack) {
+        const enabled = stack.entries.filter((e) => !e.disabled);
+        await Promise.all(enabled.map((entry) => this.spawnChild(entry)));
+    }
+    async spawnChild(entry) {
+        const transport = new StdioClientTransport({
+            command: entry.command,
+            args: entry.args,
+            env: entry.env ? { ...inheritedEnv(), ...entry.env } : undefined,
+            // Pipe child stderr through ours so server log lines aren't lost.
+            stderr: "pipe",
+        });
+        const client = new Client({ name: `curatedmcp-launcher-proxy:${entry.slug}`, version: "1.0.0" }, { capabilities: {} });
+        const state = {
+            entry,
+            client,
+            toolNames: new Set(),
+        };
+        this.children.set(entry.slug, state);
+        try {
+            await client.connect(transport);
+            // Pre-fetch tool list so aggregateTools() is fast and we know what we route.
+            const list = await client.listTools();
+            state.toolNames = new Set(list.tools.map((t) => t.name));
+            // Pipe child stderr to ours (best-effort) for visibility into upstream issues.
+            const childStderr = transport.stderr;
+            if (childStderr && typeof childStderr.on === "function") {
+                childStderr.on("data", (chunk) => {
+                    process.stderr.write(`[${entry.slug}] ${chunk.toString()}`);
+                });
+            }
+            console.error(`[launcher] Proxied ${entry.slug} (${state.toolNames.size} tools)`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            state.error = `Failed to connect to ${entry.slug}: ${message}`;
+            console.error(`[launcher] ${state.error}`);
+        }
+    }
+    /**
+     * Returns all tools from all healthy children, prefixed with `<slug>__`.
+     * Disabled or unhealthy children contribute nothing.
+     */
+    async aggregateTools() {
+        const out = [];
+        for (const [slug, state] of this.children) {
+            if (state.error)
+                continue;
+            try {
+                const list = await state.client.listTools();
+                // Refresh cached tool names in case the child added/removed tools.
+                state.toolNames = new Set(list.tools.map((t) => t.name));
+                for (const t of list.tools) {
+                    out.push({
+                        name: `${slug}${PREFIX_SEPARATOR}${t.name}`,
+                        description: t.description
+                            ? `[${slug}] ${t.description}`
+                            : `[${slug}] (proxied)`,
+                        inputSchema: t.inputSchema,
+                    });
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                state.error = `listTools failed: ${message}`;
+                console.error(`[launcher] [${slug}] ${state.error}`);
+            }
+        }
+        return out;
+    }
+    /**
+     * Route a `<slug>__<tool>` call to the right child and return its response unchanged.
+     * Throws if the prefix doesn't match any known child or if the child is unhealthy.
+     */
+    async routeCall(prefixedName, args) {
+        const sepIdx = prefixedName.indexOf(PREFIX_SEPARATOR);
+        if (sepIdx <= 0) {
+            throw new Error(`Tool name "${prefixedName}" is missing the "<slug>__" prefix.`);
+        }
+        const slug = prefixedName.slice(0, sepIdx);
+        const toolName = prefixedName.slice(sepIdx + PREFIX_SEPARATOR.length);
+        const state = this.children.get(slug);
+        if (!state) {
+            throw new Error(`Server "${slug}" is not in your stack. Run \`launcher list\` to see what's loaded.`);
+        }
+        if (state.error) {
+            throw new Error(state.error);
+        }
+        return state.client.callTool({
+            name: toolName,
+            arguments: args,
+        });
+    }
+    /** Cleanly close all child clients. Best-effort; never throws. */
+    async shutdown() {
+        await Promise.all(Array.from(this.children.values()).map((s) => s.client.close().catch(() => { })));
+        this.children.clear();
+    }
+}
+/**
+ * Minimal env passthrough. We don't want to leak the parent's full env to children
+ * because that often includes secrets meant for other tools — but the child needs
+ * the basics (PATH, HOME, etc.) to even spawn.
+ */
+function inheritedEnv() {
+    const keys = [
+        "PATH",
+        "HOME",
+        "USER",
+        "USERNAME",
+        "USERPROFILE",
+        "APPDATA",
+        "LOCALAPPDATA",
+        "TEMP",
+        "TMP",
+        "LANG",
+        "LC_ALL",
+        "SHELL",
+        "TERM",
+        "PWD",
+        // Allow npx/uvx to find their caches without forcing global install
+        "NPM_CONFIG_CACHE",
+        "UV_CACHE_DIR",
+        "XDG_CACHE_HOME",
+    ];
+    const out = {};
+    for (const k of keys) {
+        const v = process.env[k];
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+//# sourceMappingURL=proxy.js.map

package/dist/stack.d.ts

@@ -0,0 +1,45 @@
+export interface StackEntry {
+    /** CuratedMCP catalog slug (e.g. "github", "postgres"). */
+    slug: string;
+    /** Executable to spawn (e.g. "npx", "uvx", "node", "/usr/local/bin/foo"). */
+    command: string;
+    /** Args passed to the executable. */
+    args: string[];
+    /** Optional env vars (API keys, tokens, paths). */
+    env?: Record<string, string>;
+    /** When set, the entry is in stack.json but not loaded by the proxy. */
+    disabled?: boolean;
+    /** Free-form note (e.g. "Personal account"). */
+    note?: string;
+    /** Display name for `launcher list`. Falls back to slug. */
+    name?: string;
+    /** ISO timestamp of when this was added. */
+    addedAt?: string;
+}
+export interface Stack {
+    /** Schema version. Bump when the schema is not backward-compatible. */
+    version: 1;
+    entries: StackEntry[];
+}
+/** Returns the path to stack.json (so callers can show it to users). */
+export declare function stackPath(): string;
+/**
+ * Read the stack from disk.
+ * Returns an empty stack if the file is missing, unreadable, or malformed —
+ * so a corrupt config never crashes the launcher.
+ */
+export declare function readStack(): Stack;
+/**
+ * Atomically write the stack to disk.
+ * Writes to a temp sibling file, then renames — avoids a half-written file
+ * if the process is killed mid-write.
+ */
+export declare function writeStack(stack: Stack): void;
+/**
+ * Add or replace an entry by slug. If an entry with the same slug exists,
+ * it's overwritten (so calling `add` twice updates env vars cleanly).
+ */
+export declare function upsertEntry(entry: StackEntry): Stack;
+/** Remove an entry by slug. No-op (returns false) if it wasn't there. */
+export declare function removeEntry(slug: string): boolean;
+//# sourceMappingURL=stack.d.ts.map

package/dist/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../src/stack.ts"],"names":[],"mappings":"AAqBA,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,mDAAmD;IACnD,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gDAAgD;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,KAAK;IACpB,uEAAuE;IACvE,OAAO,EAAE,CAAC,CAAC;IACX,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAID,wEAAwE;AACxE,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,KAAK,CAgBjC;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAO7C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAcpD;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOjD"}