@mastra/mcp-registry-registry 0.0.1-alpha.1

package/LICENSE.md

@@ -0,0 +1,46 @@
+# Elastic License 2.0 (ELv2)
+
+Copyright (c) 2025 Mastra AI, Inc.
+
+**Acceptance**
+By using the software, you agree to all of the terms and conditions below.
+
+**Copyright License**
+The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below
+
+**Limitations**
+You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality in the software, and you may not remove or obscure any functionality in the software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices of the licensor in the software. Any use of the licensor’s trademarks is subject to applicable law.
+
+**Patents**
+The licensor grants you a license, under any patent claims the licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case subject to the limitations and conditions in this license. This license does not cover any patent claims that you cause to be infringed by modifications or additions to the software. If you or your company make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+**Notices**
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the software prominent notices stating that you have modified the software.
+
+**No Other Rights**
+These terms do not imply any licenses other than those expressly granted in these terms.
+
+**Termination**
+If you use the software in violation of these terms, such use is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently.
+
+**No Liability**
+As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.
+
+**Definitions**
+The _licensor_ is the entity offering these terms, and the _software_ is the software the licensor makes available under these terms, including any portion of it.
+
+_you_ refers to the individual or entity agreeing to these terms.
+
+_your company_ is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. _control_ means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.
+
+_your licenses_ are all the licenses granted to you for the software under these terms.
+
+_use_ means anything you do with the software requiring one of your licenses.
+
+_trademark_ means trademarks, service marks, and similar rights.

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,243 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+
+export declare function createServerEntry(data: Record<string, unknown>): ServerEntry;
+
+/**
+ * Fetches servers from a registry's servers_url endpoint
+ */
+declare function fetchServersFromRegistry(registryId: string): Promise<ServerEntry[]>;
+export { fetchServersFromRegistry }
+export { fetchServersFromRegistry as fetchServersFromRegistry_alias_1 }
+
+/**
+ * Filters registry entries based on provided criteria
+ */
+declare function filterRegistries(registries: RegistryEntry[], filters: {
+    id?: string;
+    tag?: string;
+    name?: string;
+}): RegistryEntry[];
+export { filterRegistries }
+export { filterRegistries as filterRegistries_alias_1 }
+
+/**
+ * Filters server entries based on provided criteria
+ */
+declare function filterServers(servers: ServerEntry[], filters: {
+    tag?: string;
+    search?: string;
+}): ServerEntry[];
+export { filterServers }
+export { filterServers as filterServers_alias_1 }
+
+/**
+ * Formats registry entries for API response
+ */
+declare function formatRegistryResponse(registries: RegistryEntry[], detailed?: boolean): any;
+export { formatRegistryResponse }
+export { formatRegistryResponse as formatRegistryResponse_alias_1 }
+
+export declare function fromPackageRoot(relativePath: string): string;
+
+/**
+ * Main function to get registry listings with optional filtering
+ */
+declare function getRegistryListings(filters?: {
+    id?: string;
+    tag?: string;
+    name?: string;
+}, options?: {
+    detailed?: boolean;
+}): Promise<any>;
+export { getRegistryListings }
+export { getRegistryListings as getRegistryListings_alias_1 }
+
+/**
+ * Main function to get servers from a registry with optional filtering
+ */
+declare function getServersFromRegistry(registryId: string, filters?: {
+    tag?: string;
+    search?: string;
+}): Promise<any>;
+export { getServersFromRegistry }
+export { getServersFromRegistry as getServersFromRegistry_alias_1 }
+
+export declare const listInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    detailed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    detailed: boolean;
+    id?: string | undefined;
+    name?: string | undefined;
+    tag?: string | undefined;
+}, {
+    id?: string | undefined;
+    name?: string | undefined;
+    tag?: string | undefined;
+    detailed?: boolean | undefined;
+}>;
+
+export declare const listTool: {
+    name: string;
+    description: string;
+    execute(input: ListToolInput): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};
+
+export declare type ListToolInput = z.infer<typeof listInputSchema>;
+
+/**
+ * Returns the registry data from the registry.ts file
+ */
+declare function loadRegistryData(): Promise<RegistryFile>;
+export { loadRegistryData }
+export { loadRegistryData as loadRegistryData_alias_1 }
+
+/**
+ * Post-processor for Apify registry
+ * Handles the specific format of Apify's store data
+ */
+export declare function processApifyServers(data: any): ServerEntry[];
+
+/**
+ * Post-processor for APITracker registry
+ * Handles the specific format of APITracker's server data
+ */
+export declare function processApiTrackerServers(data: unknown): ServerEntry[];
+
+/**
+ * Default processor for registry server data
+ * Handles common formats that might be encountered
+ */
+export declare function processDefaultServers(data: unknown): ServerEntry[];
+
+/**
+ * Post-processor for Fleur registry
+ * Handles the specific format of Fleur's app data
+ */
+export declare function processFleurServers(data: unknown): ServerEntry[];
+
+export declare function processMcpRunServers(data: any): ServerEntry[];
+
+/**
+ * Post-processor for Pulse MCP registry
+ * Handles the specific format of Pulse MCP's server data
+ */
+export declare function processPulseMcpServers(data: any): ServerEntry[];
+
+declare const registryData: RegistryFile;
+export { registryData }
+export { registryData as registryData_alias_1 }
+
+export declare interface RegistryEntry {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    servers_url?: string;
+    tags?: string[];
+    count?: number | string;
+    postProcessServers?: (data: unknown) => ServerEntry[];
+}
+
+export declare interface RegistryFile {
+    registries: RegistryEntry[];
+}
+
+export declare function runServer(): Promise<void>;
+
+export declare const server: Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+    } | undefined;
+}>;
+
+export declare type ServerEntry = z.infer<typeof ServerEntrySchema>;
+
+export declare const ServerEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+}, {
+    id: string;
+    name: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+}>;
+
+export declare const serversInputSchema: z.ZodObject<{
+    registryId: z.ZodString;
+    tag: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    registryId: string;
+    tag?: string | undefined;
+    search?: string | undefined;
+}, {
+    registryId: string;
+    tag?: string | undefined;
+    search?: string | undefined;
+}>;
+
+export declare const serversTool: {
+    name: string;
+    description: string;
+    execute(input: ServersToolInput): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};
+
+export declare type ServersToolInput = z.infer<typeof serversInputSchema>;
+
+export { }

package/dist/stdio.d.ts

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

package/dist/stdio.js

@@ -0,0 +1,575 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// src/registry/processors/apify.ts
+function processApifyServers(data) {
+  const apifyData = data?.data?.items || [];
+  if (!Array.isArray(apifyData)) {
+    return [];
+  }
+  return apifyData.filter((item) => item && item.name).map((item) => {
+    const stats = item.stats || {};
+    const server2 = {
+      id: item.name || "unknown",
+      name: item.title,
+      description: item.description || "No description available",
+      createdAt: "",
+      // Apify doesn't provide creation date
+      updatedAt: stats.lastRunStartedAt || ""
+    };
+    return server2;
+  });
+}
+
+// src/registry/processors/utils.ts
+function createServerEntry(data) {
+  const metaDescription = typeof data.meta === "object" && data.meta !== null ? data.meta.description : void 0;
+  return {
+    id: data.id || data.name || data.slug || "unknown",
+    name: data.name || data.id || data.slug || "Unknown Server",
+    description: data.description || metaDescription || "No description available",
+    createdAt: data.createdAt || data.created_at || "",
+    updatedAt: data.updatedAt || data.updated_at || ""
+  };
+}
+
+// src/registry/processors/apitracker.ts
+function processApiTrackerServers(data) {
+  if (!data || typeof data !== "object") {
+    return [];
+  }
+  const servers = [];
+  if (typeof data === "object" && data !== null) {
+    const dataObj = data;
+    let serversList = [];
+    if (Array.isArray(dataObj.servers)) {
+      serversList = dataObj.servers;
+    } else if (Array.isArray(dataObj.items)) {
+      serversList = dataObj.items;
+    } else if (Array.isArray(data)) {
+      serversList = data;
+    }
+    for (const item of serversList) {
+      if (typeof item === "object" && item !== null) {
+        servers.push(createServerEntry(item));
+      }
+    }
+  }
+  return servers;
+}
+
+// src/registry/processors/fleur.ts
+function processFleurServers(data) {
+  if (!data || typeof data !== "object") {
+    return [];
+  }
+  const servers = [];
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      if (typeof item === "object" && item !== null) {
+        const server2 = createServerEntry(item);
+        if (item.appId) {
+          server2.id = item.appId;
+        }
+        servers.push(server2);
+      }
+    }
+  }
+  return servers;
+}
+
+// src/registry/processors/mcprun.ts
+function processMcpRunServers(data) {
+  const serversData = data;
+  if (!Array.isArray(serversData)) {
+    return [];
+  }
+  return serversData.filter((item) => item && item.slug).map((item) => {
+    const server2 = {
+      id: item.slug,
+      name: item.slug,
+      description: item?.meta?.description,
+      createdAt: item?.created_at,
+      updatedAt: item?.updated_at
+    };
+    return server2;
+  });
+}
+
+// src/registry/processors/pulse.ts
+function processPulseMcpServers(data) {
+  const serversData = data?.servers || [];
+  if (!Array.isArray(serversData)) {
+    return [];
+  }
+  return serversData.filter((item) => item && item.name).map((item) => {
+    const server2 = {
+      id: item.name || "unknown",
+      name: item.name || "Unknown Server",
+      description: item.short_description.slice(0, 300) || item.EXPERIMENTAL_ai_generated_description.slice(0, 300) || "No description available",
+      createdAt: "",
+      // Pulse MCP doesn't provide creation date
+      updatedAt: ""
+      // Pulse MCP doesn't provide update date
+    };
+    return server2;
+  }).slice(0, 1e3);
+}
+
+// src/registry/registry.ts
+var registryData = {
+  registries: [
+    {
+      id: "apitracker",
+      name: "apitracker",
+      description: "Discover the best APIs and developer resources",
+      url: "https://apitracker.com/",
+      servers_url: "https://apitracker.io/api/mcp-servers",
+      tags: ["verified"],
+      postProcessServers: processApiTrackerServers
+    },
+    {
+      id: "apify",
+      name: "Apify",
+      description: "Your full\u2011stack platform for web scraping",
+      url: "https://apify.com/",
+      servers_url: "https://api.apify.com/v2/store",
+      tags: ["verified"],
+      postProcessServers: processApifyServers
+    },
+    {
+      id: "fleur",
+      name: "Fleur",
+      description: "Fleur is the app store for Claude",
+      url: "https://www.fleurmcp.com/",
+      servers_url: "https://raw.githubusercontent.com/fleuristes/app-registry/refs/heads/main/apps.json",
+      tags: ["verified"],
+      postProcessServers: processFleurServers
+    },
+    {
+      id: "modelcontextprotocol-servers",
+      name: "modelcontextprotocol/servers",
+      description: "This repository is a collection of reference implementations for the Model Context Protocol (MCP).",
+      url: "https://github.com/modelcontextprotocol/servers",
+      tags: ["official"],
+      count: 307
+    },
+    {
+      id: "awesome-mcp-servers",
+      name: "Awesome MCP servers",
+      description: "A curated list of awesome Model Context Protocol (MCP) servers.",
+      url: "https://github.com/punkpeye/awesome-mcp-servers",
+      tags: ["open-source"],
+      count: 370
+    },
+    {
+      id: "cline-bot",
+      name: "Cline.bot",
+      description: "MCP servers for Cline.bot",
+      url: "https://cline.bot/mcp-marketplace",
+      tags: ["verified"]
+    },
+    {
+      id: "cursor-mcp-registry",
+      name: "Cursor MCP Registry",
+      description: "Browse MCPs or post a MCP to reach 250,000+ monthly active developers.",
+      url: "https://cursor.directory/mcp",
+      tags: ["verified"],
+      count: "1800+"
+    },
+    {
+      id: "glama-mcp-server",
+      name: "Glama MCP Server",
+      description: "Production-ready and experimental MCP servers that extend AI capabilities.",
+      url: "https://glama.ai/mcp/servers",
+      tags: ["open-source"],
+      count: 3457
+    },
+    {
+      id: "gumloop",
+      name: "Gumloop",
+      description: "An exhaustive list of MCP servers.",
+      url: "https://www.gumloop.com/mcp",
+      tags: ["open-source"],
+      count: 20
+    },
+    {
+      id: "mcp-composio",
+      name: "MCP Composio",
+      description: "Instantly Connect to 100+ Managed MCP Servers with Built-In Auth",
+      url: "https://mcp.composio.dev/",
+      tags: ["verified"],
+      count: "100+"
+    },
+    {
+      id: "mcp-market",
+      name: "MCP Market",
+      description: "Explore our curated collection of MCP servers to connect AI to your favorite tools.",
+      url: "https://mcpmarket.com/",
+      count: 12454
+    },
+    {
+      id: "mcp-run",
+      name: "MCP Run",
+      description: "One platform for vertical AI across your entire organization.",
+      url: "https://www.mcp.run/",
+      servers_url: "https://www.mcp.run/api/servlets",
+      tags: ["verified"],
+      postProcessServers: processMcpRunServers
+    },
+    {
+      id: "mcp-servers-org",
+      name: "MCP Servers",
+      description: "A collection of servers for the Model Context Protocol.",
+      url: "https://mcpservers.org/",
+      tags: ["open-source"],
+      count: 212
+    },
+    {
+      id: "mcp-get",
+      name: "MCP-Get",
+      description: "mcp-get helps you easily install protocol servers.",
+      url: "https://mcp-get.com/",
+      tags: ["open-source"],
+      count: 69
+    },
+    {
+      id: "mcp-so",
+      name: "MCP.so",
+      description: "Find Awesome MCP Servers and Clients",
+      url: "https://mcp.so/",
+      tags: ["verified"],
+      count: 7682
+    },
+    {
+      id: "opentools",
+      name: "OpenTools",
+      description: "This registry documents the capabilities of 400+ tools across 160+ MCP servers.",
+      url: "https://opentools.com/registry",
+      tags: ["verified"],
+      count: 171
+    },
+    {
+      id: "pulse-mcp",
+      name: "Pulse MCP",
+      description: "Browse and discover MCP use cases, servers, clients, and news.",
+      url: "https://www.pulsemcp.com/",
+      servers_url: "https://api.pulsemcp.com/v0beta/servers",
+      tags: ["verified"],
+      count: 3653,
+      postProcessServers: processPulseMcpServers
+    },
+    {
+      id: "smithery",
+      name: "Smithery",
+      description: "Extend your agent with 4,274 capabilities via Model Context Protocol servers.",
+      url: "https://smithery.ai/",
+      servers_url: "https://registry.smithery.ai/servers",
+      tags: ["verified"],
+      count: 4274
+    },
+    {
+      id: "zapier-mcp",
+      name: "Zapier MCP",
+      description: "Connect your AI to any app with Zapier MCP",
+      url: "https://zapier.com/mcp",
+      tags: ["verified"]
+    }
+  ]
+};
+
+// src/registry/list-registries.ts
+var RegistryEntrySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  url: z.string().url(),
+  servers_url: z.string().url().optional(),
+  tags: z.array(z.string()).optional(),
+  count: z.union([z.number(), z.string()]).optional()
+});
+var RegistryFileSchema = z.object({
+  registries: z.array(RegistryEntrySchema)
+});
+async function loadRegistryData() {
+  try {
+    return RegistryFileSchema.parse(registryData);
+  } catch (error) {
+    console.error("Error loading registry data:", error);
+    return { registries: [] };
+  }
+}
+function filterRegistries(registries, filters) {
+  let filteredRegistries = [...registries];
+  if (filters.id) {
+    filteredRegistries = filteredRegistries.filter((registry) => registry.id === filters.id);
+  }
+  if (filters.tag) {
+    filteredRegistries = filteredRegistries.filter((registry) => registry.tags?.includes(filters.tag));
+  }
+  if (filters.name) {
+    const searchTerm = filters.name.toLowerCase();
+    filteredRegistries = filteredRegistries.filter((registry) => registry.name.toLowerCase().includes(searchTerm));
+  }
+  return filteredRegistries;
+}
+function formatRegistryResponse(registries, detailed = false) {
+  if (registries.length === 0) {
+    return {
+      count: 0,
+      registries: []
+    };
+  }
+  if (detailed) {
+    return {
+      count: registries.length,
+      registries: registries.map((registry) => ({
+        id: registry.id,
+        name: registry.name,
+        description: registry.description,
+        url: registry.url,
+        servers_url: registry.servers_url,
+        tags: registry.tags || [],
+        count: registry.count
+      }))
+    };
+  }
+  return {
+    count: registries.length,
+    registries: registries.map((registry) => ({
+      id: registry.id,
+      name: registry.name,
+      description: registry.description
+    }))
+  };
+}
+async function getRegistryListings(filters = {}, options = {}) {
+  try {
+    const registryData2 = await loadRegistryData();
+    const filteredRegistries = filterRegistries(registryData2.registries, filters);
+    return formatRegistryResponse(filteredRegistries, options.detailed);
+  } catch (error) {
+    console.error("Error getting registry listings:", error);
+    throw error;
+  }
+}
+
+// src/tools/list.ts
+var listInputSchema = z.object({
+  id: z.string().optional(),
+  tag: z.string().optional(),
+  name: z.string().optional(),
+  detailed: z.boolean().optional().default(false)
+});
+var listTool = {
+  name: "registryList",
+  description: "List available MCP registries. Can filter by ID, tag, or name and provide detailed or summary views.",
+  async execute(input) {
+    try {
+      const result = await getRegistryListings(
+        {
+          id: input.id,
+          tag: input.tag,
+          name: input.name
+        },
+        {
+          detailed: input.detailed
+        }
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error listing registries: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+};
+
+// src/registry/fetch-servers.ts
+async function fetchServersFromRegistry(registryId) {
+  try {
+    const registry = registryData.registries.find((r) => r.id === registryId);
+    if (!registry) {
+      throw new Error(`Registry with ID "${registryId}" not found.`);
+    }
+    if (!registry.servers_url) {
+      throw new Error(`Registry "${registry.name}" does not have a servers endpoint.`);
+    }
+    console.log(`Fetching servers from ${registry.name} at ${registry.servers_url}`);
+    const response = await fetch(registry.servers_url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch servers from ${registry.servers_url}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (registry.postProcessServers) {
+      console.log(`Using custom post-processor for ${registry.name}`);
+      return registry.postProcessServers(data);
+    }
+    throw new Error(`No post-processor found for registry ${registry.name}`);
+  } catch (error) {
+    console.error("Error fetching servers:", error);
+    throw error;
+  }
+}
+function filterServers(servers, filters) {
+  let filteredServers = [...servers];
+  if (filters.search) {
+    const searchTerm = filters.search.toLowerCase();
+    filteredServers = filteredServers.filter(
+      (server2) => server2.name.toLowerCase().includes(searchTerm) || server2.description.toLowerCase().includes(searchTerm)
+    );
+  }
+  return filteredServers;
+}
+async function getServersFromRegistry(registryId, filters = {}) {
+  try {
+    const servers = await fetchServersFromRegistry(registryId);
+    return filterServers(servers, filters);
+  } catch (error) {
+    console.error("Error getting servers from registry:", error);
+    throw error;
+  }
+}
+
+// src/tools/servers.ts
+var serversInputSchema = z.object({
+  registryId: z.string(),
+  tag: z.string().optional(),
+  search: z.string().optional()
+});
+var serversTool = {
+  name: "registryServers",
+  description: "Get servers from a specific MCP registry. Can filter by tag or search term.",
+  async execute(input) {
+    try {
+      const result = await getServersFromRegistry(input.registryId, {
+        search: input.search
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error fetching servers: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+};
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function fromPackageRoot(relativePath) {
+  return path.resolve(__dirname, "..", relativePath);
+}
+
+// src/server.ts
+var server = new Server(
+  {
+    name: "Registry Registry Server",
+    version: JSON.parse(await fs.readFile(fromPackageRoot(`package.json`), "utf8")).version
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "registryList",
+      description: listTool.description,
+      inputSchema: zodToJsonSchema(listInputSchema)
+    },
+    {
+      name: "registryServers",
+      description: serversTool.description,
+      inputSchema: zodToJsonSchema(serversInputSchema)
+    }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    switch (request.params.name) {
+      case "registryList": {
+        const args = listInputSchema.parse(request.params.arguments);
+        return await listTool.execute(args);
+      }
+      case "registryServers": {
+        const args = serversInputSchema.parse(request.params.arguments);
+        return await serversTool.execute(args);
+      }
+      default:
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unknown tool: ${request.params.name}`
+            }
+          ],
+          isError: true
+        };
+    }
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Invalid arguments: ${error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+async function runServer() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Registry Registry MCP Server running on stdio");
+}
+
+// src/stdio.ts
+runServer().catch((error) => {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@mastra/mcp-registry-registry",
+  "version": "0.0.1-alpha.1",
+  "description": "MCP server for registry registry services.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": "dist/stdio.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "Elastic-2.0",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.9.0",
+    "uuid": "^11.1.0",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.22.4",
+    "@mastra/core": "^0.8.3-alpha.2"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^1.13.8",
+    "@types/node": "^20.11.24",
+    "@wong2/mcp-cli": "^1.6.0",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.23.0",
+    "hono": "^4.7.4",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.3.3",
+    "vitest": "^3.0.9",
+    "@internal/lint": "0.0.2-alpha.0",
+    "@mastra/mcp": "^0.3.10-alpha.3"
+  },
+  "scripts": {
+    "build:cli": "tsup src/stdio.ts --format esm --experimental-dts --treeshake=smallest --splitting",
+    "pretest": "pnpm turbo build --filter @mastra/mcp-registry-registry",
+    "test": "vitest run",
+    "lint": "eslint ."
+  }
+}