@zhanguym/chatroom 1.2.0-beta.0 → 1.2.0-beta.2

package/dist/mcp/custom/manager.js

@@ -0,0 +1,494 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { Client, StreamableHTTPClientTransport, UnauthorizedError, SdkHttpError, } from "@modelcontextprotocol/client";
+import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/client/stdio";
+import { fromJsonSchema } from "@modelcontextprotocol/server";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+import { CustomMcpOAuthProvider, CustomMcpOAuthStore } from "./oauth.js";
+const CONNECT_TIMEOUT = 10000;
+const TOOL_TIMEOUT = 60000;
+async function withConnectTimeout(promise) {
+    let timeout = null;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => reject(new Error("MCP connection timed out")), CONNECT_TIMEOUT);
+                timeout.unref();
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+function isAuthenticationError(error) {
+    return (error instanceof UnauthorizedError ||
+        (error instanceof SdkHttpError && error.status === 401));
+}
+const toolId = (id, name) => "custom_" + id + "__" + name;
+function validate(config) {
+    if (!config.name?.trim() || config.name.length > 100)
+        throw new ChatRoomError("INVALID_INPUT", "Invalid MCP server name");
+    if (config.type === "stdio") {
+        if (!config.command?.trim())
+            throw new ChatRoomError("INVALID_INPUT", "Missing executable");
+        if (config.args &&
+            (!Array.isArray(config.args) ||
+                config.args.some((value) => typeof value !== "string")))
+            throw new ChatRoomError("INVALID_INPUT", "args must be an array of strings");
+    }
+    else if (config.type === "http") {
+        let url;
+        try {
+            url = new URL(config.url ?? "");
+        }
+        catch {
+            throw new ChatRoomError("INVALID_INPUT", "Invalid MCP URL");
+        }
+        if (!["http:", "https:"].includes(url.protocol) ||
+            url.username ||
+            url.password)
+            throw new ChatRoomError("INVALID_INPUT", "Unsupported MCP URL");
+    }
+    else
+        throw new ChatRoomError("INVALID_INPUT", "Unsupported MCP transport");
+    for (const values of [config.env, config.headers]) {
+        if (values &&
+            (typeof values !== "object" ||
+                Array.isArray(values) ||
+                Object.entries(values).some(([key, value]) => !key.trim() || typeof value !== "string")))
+            throw new ChatRoomError("INVALID_INPUT", "Environment variables and headers must be string maps");
+    }
+}
+function newEntry(config) {
+    return {
+        config,
+        tools: [],
+        client: null,
+        status: config.enabled ? "connecting" : "disabled",
+        error: null,
+        pending: null,
+        retry: null,
+    };
+}
+export class CustomMcpManager {
+    repository;
+    control;
+    operations;
+    oauth;
+    authorizationFlows = new Map();
+    entries = new Map();
+    closed = false;
+    constructor(repository, control, operations, dataDir) {
+        this.repository = repository;
+        this.control = control;
+        this.operations = operations;
+        this.oauth = dataDir ? new CustomMcpOAuthStore(dataDir) : null;
+        for (const config of repository.list())
+            this.entries.set(config.id, newEntry(config));
+    }
+    start() {
+        for (const entry of this.entries.values())
+            if (entry.config.enabled)
+                void this.connect(entry);
+    }
+    list() {
+        return [...this.entries.values()].map((entry) => ({
+            id: entry.config.id,
+            name: entry.config.name,
+            type: entry.config.type,
+            ...(entry.config.command ? { command: entry.config.command } : {}),
+            ...(entry.config.args ? { args: entry.config.args } : {}),
+            ...(entry.config.cwd ? { cwd: entry.config.cwd } : {}),
+            ...(entry.config.url ? { url: entry.config.url } : {}),
+            envKeys: Object.keys(entry.config.env ?? {}),
+            headerKeys: Object.keys(entry.config.headers ?? {}),
+            enabled: entry.config.enabled,
+            authMode: this.authMode(entry.config),
+            authorized: Boolean(this.oauth &&
+                entry.config.type === "http" &&
+                this.oauth.load(entry.config.id).tokens),
+            status: entry.status,
+            error: entry.error,
+            tools: entry.tools.map((tool) => ({
+                name: toolId(entry.config.id, tool.name),
+                title: tool.title ?? tool.name,
+                description: tool.description ?? "",
+                enabled: this.control.isEnabled(toolId(entry.config.id, tool.name)),
+            })),
+        }));
+    }
+    async create(input) {
+        const config = { ...input, id: randomUUID().replaceAll("-", "") };
+        validate(config);
+        const entry = newEntry(config);
+        this.repository.save(config);
+        this.entries.set(config.id, entry);
+        if (config.enabled)
+            await this.connect(entry);
+        return this.summary(config.id);
+    }
+    async update(id, input) {
+        const previous = this.require(id);
+        const config = { ...previous.config, ...input, id };
+        validate(config);
+        const entry = newEntry(config);
+        if (previous.config.url !== config.url ||
+            previous.config.type !== config.type ||
+            this.authMode(previous.config) !== this.authMode(config)) {
+            this.dropPendingAuthorization(id);
+            this.oauth?.clear(id);
+        }
+        this.repository.save(config);
+        this.entries.set(id, entry);
+        await this.dispose(previous);
+        if (config.enabled)
+            await this.connect(entry);
+        return this.summary(id);
+    }
+    async remove(id) {
+        const entry = this.require(id);
+        this.entries.delete(id);
+        this.repository.delete(id);
+        this.dropPendingAuthorization(id);
+        this.oauth?.clear(id);
+        await this.dispose(entry);
+    }
+    async refresh(id) {
+        const entry = this.require(id);
+        if (!entry.config.enabled)
+            throw new ChatRoomError("INVALID_INPUT", "Enable the MCP server before refreshing");
+        return this.update(id, {});
+    }
+    async test(input) {
+        // Test connections are ephemeral, but OAuthStore requires a valid server ID.
+        // Never persist a temporary test entry or its credentials.
+        const config = { ...input, id: randomUUID().replaceAll("-", "") };
+        validate(config);
+        return this.probe(config);
+    }
+    async testStored(id) {
+        const entry = this.require(id);
+        if (entry.status === "connected")
+            return { tools: entry.tools.length };
+        return this.probe(entry.config);
+    }
+    async probe(config) {
+        const client = new Client({ name: "chatroom-test", version: "1.0.0" });
+        try {
+            await withConnectTimeout(client.connect(this.transport(config)));
+            const { tools } = await client.listTools(undefined, {
+                timeout: CONNECT_TIMEOUT,
+            });
+            return { tools: tools.length };
+        }
+        catch (error) {
+            if (config.type === "http" &&
+                this.authMode(config) === "auto" &&
+                isAuthenticationError(error))
+                return { tools: 0, authRequired: true };
+            throw error;
+        }
+        finally {
+            await client.close().catch(() => undefined);
+        }
+    }
+    /**
+     * Start an interactive OAuth flow for an existing HTTP MCP server.
+     * The callback state is single-use and never exposed to the browser.
+     */
+    async authorize(id, redirectUrl) {
+        const entry = this.require(id);
+        if (entry.config.type !== "http" ||
+            this.authMode(entry.config) !== "auto" ||
+            !this.oauth)
+            throw new ChatRoomError("INVALID_INPUT", "OAuth is only available for automatic HTTP MCP");
+        const redirect = new URL(redirectUrl);
+        if (redirect.pathname !== "/api/mcp/oauth/callback" ||
+            (redirect.protocol !== "https:" &&
+                !(redirect.protocol === "http:" &&
+                    ["localhost", "127.0.0.1", "::1"].includes(redirect.hostname))))
+            throw new ChatRoomError("INVALID_INPUT", "Invalid OAuth callback URL");
+        // A newer login invalidates earlier pending callbacks for the same server.
+        this.dropPendingAuthorization(id);
+        // Changing the callback URI requires fresh client registration.
+        if (this.oauth.load(id).redirectUrl !== redirectUrl)
+            this.oauth.clear(id);
+        this.oauth.patch(id, { redirectUrl, tokens: undefined });
+        const state = randomBytes(32).toString("base64url");
+        const provider = new CustomMcpOAuthProvider(id, this.oauth, state);
+        const client = new Client({ name: "chatroom-oauth", version: "1.0.0" });
+        const transport = this.transport(entry.config, provider);
+        try {
+            await withConnectTimeout(client.connect(transport));
+        }
+        catch (error) {
+            if (!provider.authorizationUrl)
+                throw error;
+            this.authorizationFlows.set(state, {
+                id,
+                expiresAt: Date.now() + 10 * 60_000,
+            });
+            entry.status = "auth_required";
+            return { authorizationUrl: provider.authorizationUrl };
+        }
+        finally {
+            await client.close().catch(() => undefined);
+        }
+        throw new ChatRoomError("INVALID_INPUT", "This MCP server does not require OAuth");
+    }
+    async completeAuthorization(query) {
+        const state = query.get("state") ?? "";
+        const pending = this.authorizationFlows.get(state);
+        if (!pending || pending.expiresAt < Date.now())
+            throw new ChatRoomError("FORBIDDEN", "Invalid or expired MCP OAuth state");
+        this.authorizationFlows.delete(state);
+        if (query.has("error"))
+            throw new ChatRoomError("FORBIDDEN", "MCP authorization denied");
+        const entry = this.require(pending.id);
+        if (!this.oauth ||
+            !query.get("code") ||
+            this.authMode(entry.config) !== "auto")
+            throw new ChatRoomError("INVALID_INPUT", "Invalid MCP authorization response");
+        const provider = new CustomMcpOAuthProvider(pending.id, this.oauth);
+        const transport = this.transport(entry.config, provider);
+        try {
+            await withConnectTimeout(transport.finishAuth(query));
+            await this.update(pending.id, { enabled: true });
+        }
+        finally {
+            await transport.close().catch(() => undefined);
+        }
+    }
+    async revokeAuthorization(id) {
+        this.require(id);
+        this.dropPendingAuthorization(id);
+        this.oauth?.clear(id);
+        await this.update(id, { enabled: false });
+    }
+    dropPendingAuthorization(id) {
+        for (const [state, flow] of this.authorizationFlows)
+            if (flow.id === id)
+                this.authorizationFlows.delete(state);
+    }
+    authMode(config) {
+        return (config.authMode ??
+            (Object.keys(config.headers ?? {}).length ? "headers" : "auto"));
+    }
+    registerMcp(server) {
+        for (const entry of this.entries.values()) {
+            if (!entry.config.enabled || entry.status !== "connected")
+                continue;
+            for (const tool of entry.tools) {
+                const name = toolId(entry.config.id, tool.name);
+                const registered = server.registerTool(name, {
+                    title: tool.title ?? tool.name,
+                    description: tool.description ?? "",
+                    inputSchema: fromJsonSchema(tool.inputSchema),
+                    ...(tool.outputSchema
+                        ? {
+                            outputSchema: fromJsonSchema(tool.outputSchema),
+                        }
+                        : {}),
+                    ...(tool.annotations ? { annotations: tool.annotations } : {}),
+                }, async (args) => this.call(entry.config.id, tool.name, args));
+                this.control.attach(name, registered);
+            }
+        }
+    }
+    async call(id, name, args) {
+        const entry = this.entries.get(id);
+        if (!entry?.config.enabled ||
+            !entry.client ||
+            entry.status !== "connected" ||
+            !entry.tools.some((tool) => tool.name === name) ||
+            !this.control.isEnabled(toolId(id, name)))
+            throw new ChatRoomError("NOT_FOUND", "Custom MCP tool is unavailable");
+        const client = entry.client;
+        const operation = this.operations.start({
+            pluginId: "custom-mcp",
+            source: "mcp",
+            action: entry.config.name + "/" + name,
+            input: { serverId: id, toolName: name },
+        });
+        try {
+            const result = await client.callTool({ name, arguments: args }, { timeout: TOOL_TIMEOUT });
+            this.operations.finish(operation.operationId, result.isError ? "error" : "success", {
+                isError: Boolean(result.isError),
+                contentItems: result.content?.length ?? 0,
+            });
+            return result;
+        }
+        catch (error) {
+            this.operations.finish(operation.operationId, "error", null, {
+                message: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async connect(entry) {
+        if (entry.pending)
+            return entry.pending;
+        if (!entry.config.enabled || this.closed)
+            return;
+        entry.status = "connecting";
+        entry.error = null;
+        const task = this.open(entry);
+        entry.pending = task;
+        try {
+            await task;
+        }
+        finally {
+            if (entry.pending === task)
+                entry.pending = null;
+        }
+    }
+    async open(entry) {
+        const client = new Client({ name: "chatroom-gateway", version: "1.0.0" });
+        client.onclose = () => {
+            if (this.entries.get(entry.config.id) !== entry ||
+                entry.client !== client)
+                return;
+            entry.client = null;
+            entry.status = "error";
+            entry.error = "MCP connection closed";
+            this.forgetTools(entry);
+            this.scheduleRetry(entry);
+        };
+        try {
+            const transport = this.transport(entry.config);
+            await withConnectTimeout(client.connect(transport));
+            const { tools } = await client.listTools(undefined, {
+                timeout: CONNECT_TIMEOUT,
+            });
+            if (this.closed ||
+                this.entries.get(entry.config.id) !== entry ||
+                !entry.config.enabled)
+                return;
+            if (tools.length > 200)
+                throw new Error("MCP server exposes too many tools (max 200)");
+            entry.client = client;
+            entry.tools = tools;
+            entry.status = "connected";
+            entry.error = null;
+            for (const tool of tools)
+                this.define(entry, tool);
+            client.setNotificationHandler("notifications/tools/list_changed", () => {
+                if (this.entries.get(entry.config.id) === entry)
+                    void this.refreshTools(entry).catch(() => undefined);
+            });
+        }
+        catch (error) {
+            if (this.entries.get(entry.config.id) === entry && !this.closed) {
+                const needsAuth = this.authMode(entry.config) === "auto" &&
+                    entry.config.type === "http" &&
+                    isAuthenticationError(error);
+                entry.status = needsAuth ? "auth_required" : "error";
+                entry.error = needsAuth
+                    ? null
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
+                if (!needsAuth)
+                    this.scheduleRetry(entry);
+            }
+        }
+        finally {
+            if (entry.client !== client)
+                await client.close().catch(() => undefined);
+        }
+    }
+    define(entry, tool) {
+        this.control.define({
+            name: toolId(entry.config.id, tool.name),
+            pluginId: "custom-mcp",
+            title: tool.title ?? tool.name,
+            description: tool.description ?? "",
+            defaultEnabled: false,
+        });
+    }
+    async refreshTools(entry) {
+        if (!entry.client)
+            return;
+        const { tools } = await entry.client.listTools(undefined, {
+            timeout: CONNECT_TIMEOUT,
+        });
+        if (this.entries.get(entry.config.id) !== entry ||
+            !entry.client ||
+            tools.length > 200)
+            return;
+        this.forgetTools(entry);
+        entry.tools = tools;
+        for (const tool of tools)
+            this.define(entry, tool);
+    }
+    transport(config, provider) {
+        if (config.type === "stdio")
+            return new StdioClientTransport({
+                command: config.command,
+                args: config.args ?? [],
+                ...(config.cwd ? { cwd: config.cwd } : {}),
+                env: { ...getDefaultEnvironment(), ...(config.env ?? {}) },
+                stderr: "ignore",
+            });
+        const oauth = provider ??
+            (this.oauth &&
+                this.authMode(config) === "auto" &&
+                this.oauth.load(config.id).tokens
+                ? new CustomMcpOAuthProvider(config.id, this.oauth)
+                : undefined);
+        return new StreamableHTTPClientTransport(new URL(config.url), {
+            ...(oauth ? { authProvider: oauth } : {}),
+            requestInit: {
+                headers: this.authMode(config) === "headers" ? (config.headers ?? {}) : {},
+                redirect: "error",
+            },
+        });
+    }
+    scheduleRetry(entry) {
+        if (entry.retry || !entry.config.enabled || this.closed)
+            return;
+        entry.retry = setTimeout(() => {
+            entry.retry = null;
+            if (this.entries.get(entry.config.id) === entry)
+                void this.connect(entry);
+        }, 15000);
+        entry.retry.unref();
+    }
+    forgetTools(entry) {
+        for (const tool of entry.tools)
+            this.control.undefine(toolId(entry.config.id, tool.name));
+        entry.tools = [];
+    }
+    async disconnect(entry) {
+        if (entry.retry)
+            clearTimeout(entry.retry);
+        entry.retry = null;
+        this.forgetTools(entry);
+        const client = entry.client;
+        entry.client = null;
+        if (client)
+            await client.close().catch(() => undefined);
+    }
+    async dispose(entry) {
+        entry.config.enabled = false;
+        await this.disconnect(entry);
+    }
+    require(id) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new ChatRoomError("NOT_FOUND", "Custom MCP server not found");
+        return entry;
+    }
+    summary(id) {
+        const value = this.list().find((item) => item.id === id);
+        if (!value)
+            throw new ChatRoomError("NOT_FOUND", "Custom MCP server not found");
+        return value;
+    }
+    async close() {
+        this.closed = true;
+        await Promise.all([...this.entries.values()].map((entry) => this.dispose(entry)));
+    }
+}

package/dist/mcp/custom/oauth.d.ts

@@ -0,0 +1,38 @@
+import type { OAuthClientProvider, OAuthClientMetadata, OAuthDiscoveryState, StoredOAuthClientInformation, StoredOAuthTokens } from "@modelcontextprotocol/client";
+interface Credentials {
+    redirectUrl?: string | undefined;
+    client?: StoredOAuthClientInformation | undefined;
+    tokens?: StoredOAuthTokens | undefined;
+    verifier?: string | undefined;
+    discovery?: OAuthDiscoveryState | undefined;
+}
+/** Keep credentials outside the ordinary MCP configuration, in owner-only files. */
+export declare class CustomMcpOAuthStore {
+    private readonly directory;
+    constructor(dataDir: string);
+    private file;
+    load(id: string): Credentials;
+    patch(id: string, update: Partial<Credentials>): void;
+    clear(id: string): void;
+}
+export declare class CustomMcpOAuthProvider implements OAuthClientProvider {
+    readonly serverId: string;
+    private readonly store;
+    private readonly flowState?;
+    authorizationUrl: string | null;
+    constructor(serverId: string, store: CustomMcpOAuthStore, flowState?: string | undefined);
+    get redirectUrl(): string | undefined;
+    get clientMetadata(): OAuthClientMetadata;
+    state(): string;
+    clientInformation(): StoredOAuthClientInformation | undefined;
+    saveClientInformation(client: StoredOAuthClientInformation): void;
+    tokens(): StoredOAuthTokens | undefined;
+    saveTokens(tokens: StoredOAuthTokens): void;
+    redirectToAuthorization(url: URL): void;
+    saveCodeVerifier(verifier: string): void;
+    codeVerifier(): string;
+    saveDiscoveryState(discovery: OAuthDiscoveryState): void;
+    discoveryState(): OAuthDiscoveryState | undefined;
+    invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier" | "discovery"): void;
+}
+export {};

package/dist/mcp/custom/oauth.js

@@ -0,0 +1,116 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+/** Keep credentials outside the ordinary MCP configuration, in owner-only files. */
+export class CustomMcpOAuthStore {
+    directory;
+    constructor(dataDir) {
+        this.directory = path.join(dataDir, "custom-mcp-oauth");
+        mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+        chmodSync(this.directory, 0o700);
+    }
+    file(id) {
+        if (!/^[a-f0-9]{32}$/.test(id))
+            throw new Error("Invalid MCP server id");
+        return path.join(this.directory, id + ".json");
+    }
+    load(id) {
+        try {
+            return JSON.parse(readFileSync(this.file(id), "utf8"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return {};
+            throw error;
+        }
+    }
+    patch(id, update) {
+        const file = this.file(id);
+        const temp = file + "." + randomBytes(8).toString("hex");
+        try {
+            writeFileSync(temp, JSON.stringify({ ...this.load(id), ...update }), {
+                mode: 0o600,
+                flag: "wx",
+            });
+            renameSync(temp, file);
+            chmodSync(file, 0o600);
+        }
+        finally {
+            rmSync(temp, { force: true });
+        }
+    }
+    clear(id) {
+        rmSync(this.file(id), { force: true });
+    }
+}
+export class CustomMcpOAuthProvider {
+    serverId;
+    store;
+    flowState;
+    authorizationUrl = null;
+    constructor(serverId, store, flowState) {
+        this.serverId = serverId;
+        this.store = store;
+        this.flowState = flowState;
+    }
+    get redirectUrl() {
+        return this.store.load(this.serverId).redirectUrl;
+    }
+    get clientMetadata() {
+        return {
+            client_name: "ChatRoom",
+            redirect_uris: this.redirectUrl ? [this.redirectUrl] : [],
+            grant_types: ["authorization_code", "refresh_token"],
+            response_types: ["code"],
+            token_endpoint_auth_method: "none",
+        };
+    }
+    state() {
+        if (!this.flowState)
+            throw new Error("MCP OAuth login must be initiated from ChatRoom");
+        return this.flowState;
+    }
+    clientInformation() {
+        return this.store.load(this.serverId).client;
+    }
+    saveClientInformation(client) {
+        this.store.patch(this.serverId, { client });
+    }
+    tokens() {
+        return this.store.load(this.serverId).tokens;
+    }
+    saveTokens(tokens) {
+        this.store.patch(this.serverId, { tokens });
+    }
+    redirectToAuthorization(url) {
+        if (!this.flowState)
+            throw new Error("MCP server requires browser authorization");
+        this.authorizationUrl = url.toString();
+    }
+    saveCodeVerifier(verifier) {
+        this.store.patch(this.serverId, { verifier });
+    }
+    codeVerifier() {
+        const verifier = this.store.load(this.serverId).verifier;
+        if (!verifier)
+            throw new Error("MCP OAuth authorization has expired; retry login");
+        return verifier;
+    }
+    saveDiscoveryState(discovery) {
+        this.store.patch(this.serverId, { discovery });
+    }
+    discoveryState() {
+        return this.store.load(this.serverId).discovery;
+    }
+    invalidateCredentials(scope) {
+        const previous = this.store.load(this.serverId);
+        this.store.patch(this.serverId, {
+            client: scope === "all" || scope === "client" ? undefined : previous.client,
+            tokens: scope === "all" || scope === "tokens" ? undefined : previous.tokens,
+            verifier: scope === "all" || scope === "verifier" ? undefined : previous.verifier,
+            discovery: scope === "all" || scope === "discovery"
+                ? undefined
+                : previous.discovery,
+        });
+    }
+}

package/dist/mcp/custom/types.d.ts

@@ -0,0 +1,42 @@
+import type { Tool } from "@modelcontextprotocol/client";
+export interface CustomMcpConfig {
+    id: string;
+    name: string;
+    type: "stdio" | "http";
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    enabled: boolean;
+    authMode?: "auto" | "none" | "headers";
+}
+export interface CustomMcpServerSummary {
+    id: string;
+    name: string;
+    type: "stdio" | "http";
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    url?: string;
+    envKeys: string[];
+    headerKeys: string[];
+    enabled: boolean;
+    authMode?: "auto" | "none" | "headers";
+    authorized?: boolean;
+    status: "disabled" | "connecting" | "connected" | "auth_required" | "error";
+    error: string | null;
+    tools: Array<{
+        name: string;
+        title: string;
+        description: string;
+        enabled: boolean;
+    }>;
+}
+export type DiscoveredMcpTool = Tool;
+export interface CustomMcpStore {
+    list(): CustomMcpConfig[];
+    save(config: CustomMcpConfig): void;
+    delete(id: string): void;
+}

package/dist/mcp/custom/types.js

@@ -0,0 +1 @@
+export {};